Il framework Mockito fornisce una varietà di metodi come mock(), verify(), When(), ecc., utilizzati per testare le applicazioni Java. L'utilizzo di questi metodi predefiniti rende i test molto semplici.

Di seguito viene fornita una breve descrizione dei metodi Mockito:

come recuperare app nascoste

Metodo Mockito mock()

Viene utilizzato per creare oggetti fittizi di una determinata classe o interfaccia. Mockito ne contiene cinque deridere() metodi con argomenti diversi. Quando non assegniamo nulla ai mock, restituiranno i valori predefiniti. Tutti e cinque i metodi svolgono la stessa funzione di deridere gli oggetti.

Di seguito sono riportati i metodi mock() con parametri diversi:

metodo mock() con Class:Viene utilizzato per creare oggetti fittizi di una classe concreta o di un'interfaccia. Richiede una classe o il nome di un'interfaccia come parametro.
Sintassi: mock(Classe classToMock)metodo mock() con risposta:Viene utilizzato per creare oggetti fittizi di una classe o di un'interfaccia con una procedura specifica. È un metodo simulato avanzato, che può essere utilizzato quando si lavora con sistemi legacy. Richiede Answer come parametro insieme al nome della classe o dell'interfaccia. La risposta è un'enumerazione di risposte fittizie preconfigurate.
Sintassi: mock(Classe classToMock, Risposta defaultAnswer)metodo mock() con MockSettings:Viene utilizzato per creare oggetti simulati con alcune impostazioni non standard. Richiede MockSettings come parametro di impostazione aggiuntivo insieme al nome della classe o dell'interfaccia. MockSettings consente la creazione di oggetti fittizi con impostazioni aggiuntive.
Sintassi: mock(Classe classToMock, MockSettings mockSettings)metodo mock() con ReturnValues:Permette la creazione di oggetti fittizi di una determinata classe o interfaccia. Ora è deprecato, poiché ReturnValues ​​viene sostituito con Answer.
Sintassi: mock(Classe classToMock, ReturnValues ​​returnValues)metodo mock() con String:Viene utilizzato per creare oggetti fittizi specificando i nomi fittizi. Nel debug, la denominazione di oggetti fittizi può essere utile mentre è una cattiva scelta se utilizzata con codice grande e complesso.
Sintassi: mock(Classe classToMock, Nome stringa)

Il seguente frammento di codice mostra come utilizzare deridere() metodo:

 ToDoService doService = mock(ToDoService.class); 

Metodo Mockito quando()

Abilita metodi di stubbing. Dovrebbe essere usato quando vogliamo simulare per restituire valori specifici quando vengono chiamati metodi particolari. In parole povere, ' Quando viene chiamato il metodo XYZ(), Poi restituisci ABC.' Viene utilizzato principalmente quando c'è qualche condizione da eseguire.

Sintassi: quando(T metodoCall)

Il seguente frammento di codice mostra come utilizzare il metodo When():

 when(mock.someCode ()).thenReturn(5); 

Nel codice sopra, quindi Ritorno() è utilizzato principalmente con il Quando() metodo.

Metodo Mockito verify()

IL verificare() Il metodo viene utilizzato per verificare se alcuni metodi specificati vengono chiamati o meno. In termini semplici, convalida un determinato comportamento che si è verificato una volta durante un test. Viene utilizzato alla fine del codice di test per garantire che vengano chiamati i metodi definiti.

Il framework Mockito tiene traccia di tutte le chiamate ai metodi con i relativi parametri per deridere gli oggetti. Dopo il mocking, possiamo verificare che le condizioni definite siano soddisfatte o meno utilizzando il metodo verify(). Questo tipo di test è talvolta noto come test comportamentali. Controlla che un metodo venga chiamato con i parametri corretti invece di controllare il risultato di una chiamata al metodo.

Il metodo verify() viene utilizzato anche per testare il numero di invocazioni. Quindi possiamo testare il numero esatto di invocazioni utilizzando il file metodo delle volte, metodo almeno una volta, E al massimo metodo per un metodo deriso.

Ci sono due tipi di metodi verify() disponibili nella classe Mockito, che sono riportati di seguito:

metodo verifica():Verifica che un determinato comportamento sia avvenuto una volta.
Sintassi: verificare(T finto)metodo verify() con VerificationMode:Verifica che alcuni comportamenti si siano verificati almeno una volta, un numero esatto di volte o mai.
Sintassi: verificare(T mock, modalità VerificationMode)

Metodo Mockito spy()

Mockito fornisce un metodo per deridere parzialmente un oggetto, noto come the spiare metodo. Quando si utilizza il metodo spia, esiste un oggetto reale e vengono create spie o stub di quell'oggetto reale. Se non blocchiamo un metodo utilizzando spy, chiamerà il comportamento del metodo reale. La funzione principale del metodo spy() è quella di sovrascrivere i metodi specifici dell'oggetto reale. Una delle funzioni del metodo spy() è verificare l'invocazione di un determinato metodo.

Ci sono due tipi di metodi spy() disponibili nella classe Mockito:

metodo spia():Crea una spia dell'oggetto reale. Il metodo spia richiama i metodi reali a meno che non vengano stubizzati. Dovremmo usare le vere spie con attenzione e occasionalmente, ad esempio, quando abbiamo a che fare con il codice legacy.
Sintassi: spia(oggetto T)metodo spy() con Class:Crea un oggetto spia basato sulla classe anziché su un oggetto. Il metodo spy(T object) è particolarmente utile per spiare classi astratte perché non è possibile istanziarle.
Sintassi: spia(Classe classToSpy)

Il seguente frammento di codice mostra come utilizzare il metodo spy():

 List spyArrayList = spy(ArrayList.class); 

Metodo Mockito reset()

Il metodo Mockito reset() viene utilizzato per reimpostare i mock. Viene utilizzato principalmente per lavorare con i mock iniettati nel contenitore. Di solito, il metodo reset() produce un codice lungo e test inadeguati. È meglio creare nuovi mock piuttosto che utilizzare il metodo reset(). Questo è il motivo per cui il metodo reset() viene utilizzato raramente nei test.

La firma del metodo reset() è:

cosa rende veloce un pc

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

Metodo Mockito verifyNoMoreInteractions()

Viene utilizzato per verificare che uno qualsiasi dei mock forniti abbia interazioni non verificate. Possiamo utilizzare questo metodo dopo aver verificato tutti i mock, per assicurarci che nient'altro sia stato invocato sui mock. Rileva inoltre le invocazioni non verificate che si verificano prima del metodo di test, ad esempio, nel metodo setup(), @Before o nel costruttore. È un metodo facoltativo e non è necessario utilizzarlo in ogni test.

La firma del metodo verifyNoMoreInteractions() è:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Metodo Mockito verifyZeroInteractions()

Verifica che non si sia verificata alcuna interazione sui mock forniti. Rileva inoltre le invocazioni che si sono verificate prima del metodo di test, ad esempio, nel metodo setup(), @Before o nel costruttore.

La firma del metodo verifyZeroInteractions() è:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Metodo Mockito doThrow()

Viene utilizzato quando si esegue lo stub di un metodo void per generare un'eccezione. Crea una nuova istanza di eccezione per ogni invocazione del metodo. Esistono due tipi di metodi doThrow() disponibili nella classe Mockito con parametri diversi, come mostrato di seguito:

Metodo doThrow() con Throwable:Questo metodo viene utilizzato quando vogliamo eseguire lo stub di un metodo void con un'eccezione. Sintassi: doThrow(Lanciabile per essere lanciato)
La firma del metodo doThrow() è:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

Metodo doThrow() con Classe:Questo metodo viene utilizzato quando vogliamo eseguire lo stub di un metodo void per generare un'eccezione di una classe specificata.
Sintassi: doThrow(Classe da lanciare)
La firma del metodo doThrow() è:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

Metodo Mockito doCallRealMethod()

Si usa quando vogliamo richiamare l'implementazione reale di un metodo. In altre parole, viene utilizzato per creare simulazioni parziali di un oggetto. Viene utilizzato in rare situazioni, ad esempio per richiamare i metodi reali. È simile al metodo spy() e l'unica differenza è che risulta in un codice complesso.

La firma del metodo doCallRealMethod() è:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

Metodo Mockito doAnswer()

Viene utilizzato quando vogliamo eseguire lo stub di un metodo void con un tipo di risposta generico. La firma del metodo doAnswer() è:

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

Metodo Mockito doNothing()

Viene utilizzato per impostare i metodi void in modo che non facciano nulla. Il metodo doNothing() viene utilizzato in rare situazioni. Per impostazione predefinita, i metodi void sulle istanze mock non fanno nulla, ovvero non viene eseguita alcuna attività.

La firma del metodo doNothing() è:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

Metodo Mockito doReturn()

Viene utilizzato in quelle rare occasioni in cui non è possibile utilizzare Mockito.when(oggetto). Il metodo Mockito.when(oggetto) è sempre consigliato per lo stub perché è indipendente dai tipi di argomento e più leggibile rispetto al metodo doReturn().

La firma del metodo doReturn() è:

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

Metodo Mockito inOrder()

Viene utilizzato per creare oggetti che consentono la verifica dei mock in un ordine specifico. La verifica eseguita in ordine è più flessibile poiché non dobbiamo verificare tutte le interazioni. Dobbiamo verificare solo quelle interazioni che sono interessate al test (in ordine). Possiamo anche utilizzare il metodo inOrder() per creare un oggetto inOrder che passa mock rilevanti per la verifica in ordine.

La firma del metodo Mockito.inOrder() è:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

Metodo Mockito ignoreStubs()

Viene utilizzato per ignorare i metodi stubbed di determinati mock per la verifica. È utile con i metodi verifyNoMoreInteractions() o verify inOrder(). Aiuta anche a evitare la verifica ridondante delle chiamate stub.

La firma del metodo ignoreStubs() è:

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

Metodo Mockito times()

Viene utilizzato per verificare il numero esatto di invocazioni di metodi, il che significa che dichiara quante volte un metodo viene invocato. La firma del metodo times() è:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

Metodo Mockito never()

Viene utilizzato per verificare che l'interazione non sia avvenuta. La firma del metodo never() è:

 public static VerificationMode never() { return times(0); } 

Metodo Mockito atLeastOnce()

Viene utilizzato per verificare l'invocazione almeno una volta, il che significa che il metodo deve essere invocato almeno una volta.

La firma del metodo atLeastOnce() è:

algoritmo di ordinamento per inserimento

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

Metodo Mockito atLeast()

Viene utilizzato per verificare l'invocazione almeno x numero di volte. Ad esempio, dato atLeast(3) significa che il metodo invocherà un minimo di tre volte.

La firma del metodo atLeast() è:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

Metodo Mockito atMost()

Viene utilizzato per verificare l'invocazione al massimo x numero di volte. Ad esempio, dato atMost(3) significa che il metodo invocherà un massimo di tre volte.

La firma del metodo atMost() è:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

Mockito chiama il metodo()

Permette una verifica non avida dell'ordine. Può essere utilizzato solo con il metodo di verifica inOrder(). Ad esempio, inOrder.verify(mock,calls(3)).xyzMethod('...');

La firma del metodocalls() è:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

Metodo Mockito only()

Verifica che il metodo indicato fosse l'unico metodo invocato. La firma del metodo only() è:

stringhe di Java

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

Metodo Mockito timeout()

Consente a Mockito di eseguire la verifica con un timeout. Indica a una verifica di attendere un periodo di tempo specifico per una particolare interazione anziché fallire immediatamente. Potrebbe essere utile per testare situazioni esistenti.

Il metodo timeout() differisce dal metodo after() poiché il metodo after() attende l'intero periodo a meno che non venga dichiarato il risultato finale, mentre il metodo timeout() si interromperà non appena la verifica avrà esito positivo. Viene utilizzato raramente nei test.

La firma del metodo timeout() è:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

Metodo Mockito after()

Consente a Mockito di verificare in un determinato periodo di tempo. Abbiamo già discusso della differenza tra il metodo after() e il metodo timeout().

La firma del metodo after() è:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Metodo Mockito validateMockitoUsage()

Viene utilizzato per convalidare esplicitamente lo stato del framework per rilevare l'uso non valido del framework Mockito. È una funzionalità opzionale di Mockito perché ne convalida costantemente l'utilizzo. Sia il runner integrato (MockitoJUnitRunner) che la regola (MockitoRule) chiamano il metodo validateMockitoUsage() dopo ogni metodo di test.

La firma del metodo validateMockitoUsage() è:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

Mockito con il metodoSettings()

Viene utilizzato per creare mock con impostazioni mock aggiuntive. Dovrebbe essere usato occasionalmente durante i test. Invece di utilizzare il metodo withSettings(), crea semplici test utilizzando semplici mock. I motivi principali per utilizzare MockSettings sono

• Utilizzando MockSetting, possiamo facilmente aggiungere altre impostazioni fittizie quando necessario.
• Combina diverse impostazioni fittizie senza incasinare il codice.

La firma del metodo withSettings() è:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }