top 12 mockito interview questions
Domande di intervista Mockito più frequenti per rompere l'intervista Mockito Mocking:
Nel nostro precedente tutorial, abbiamo imparato Metodi di derisione privati, statici e nulli . Leggi il file tutorial di formazione completi su Mockito per una chiara comprensione del framework Mockito.
Questo articolo copre le domande tipiche dell'intervista più comunemente poste sul framework Mockito Mocking.
Ci si aspetta che ogni sviluppatore o QA conosca le basi del mocking per scrivere facilmente i test più white box (o unit test) e per deridere le dipendenze per una maggiore copertura del codice e una maggiore fiducia nell'applicazione.
Domande di intervista Mockito più popolari con risposte dettagliate
Di seguito sono elencate le domande più frequenti su Mocking Frameworks.
Q # 1) Perché abbiamo bisogno di prendere in giro?
Risposta: Ci sono molti casi d'uso di derisione che aiutano nei test unitari del codice in isolamento e rendono il test altamente ripetibile e prevedibile.
Il mocking è generalmente richiesto quando:
per) Il componente sottoposto a test presenta dipendenze non ancora implementate o l'implementazione è in corso.
Un buon esempio può essere un endpoint dell'API REST che sarà disponibile in un secondo momento, ma lo hai utilizzato nel codice tramite una dipendenza.
Ora, poiché l'implementazione reale non è ancora disponibile, la maggior parte delle volte sai davvero quale sia la risposta attesa di quell'API. I mock ti consentono di testare questi tipi di integrazione.
b) Il componente aggiorna lo stato nel sistema.
Esempio: Chiamate DB: non si desidera aggiornare il database con dati solo a scopo di test. Ciò potrebbe comportare la corruzione dei dati, inoltre, la disponibilità del DB è un'altra sfida quando viene eseguito il test.
Pertanto, per evitare tale comportamento, le chiamate DB potrebbero essere derise nel componente sottoposto a test. Quindi non vi è alcun accoppiamento diretto tra DB e il componente in prova.
Q # 2) Differenza tra doReturn e thenReturn.
Risposta: Mockito fornisce due diverse sintassi per la creazione di stub come:
- doReturn e quindiReturn
- non fare niente (non poi niente)
- doThrow e poiThrow
Entrambi questi metodi configurano stub e possono essere utilizzati per creare / impostare stub e potrebbero essere usati in modo intercambiabile a volte.
come trovare la chiave di sicurezza di rete per l'hotspot mobile
Quindi come differiscono entrambi?
per) Il metodo thenReturn di stubbing è un modo sicuro per i tipi di impostare gli stub. Ciò significa essenzialmente che esegue un controllo in fase di compilazione rispetto ai tipi restituiti che si desidera stubare.
Capiamo questo con un esempio:
Assumi un metodo getItemDetails su mockedItemService che restituisce un oggetto di tipo ItemSku. Quindi con quindi ritorno, non sarai in grado di restituire nient'altro che di tipo ItemSku ma con doReturn, puoi impostare lo stub per restituire qualsiasi cosa e il test fallirà (o genererà un'eccezione) durante l'esecuzione.
// lavori
when (mockedItemService.getItemDetails(123)).thenReturn(new ItemSku());// genera un'eccezione in fase di compilazione
when (mockedItemService.getItemDetails(123)).thenReturn(expectedPrice);// con doReturn, entrambe le impostazioni dello stub funzionano in quanto non sono sicure per la compilazione.
// qui stiamo cercando di restituire un oggetto di tipo double che funziona ancora e non genera alcun avviso in fase di compilazione.
doReturn (expectedPrice).when(mockedItemService.getItemDetails(123)); doReturn (new ItemSku()).when(mockedItemService.getItemDetails(123));b) Un'altra importante differenza tra questi 2 modi per lo stub è per gli oggetti Mocked, a parte la sicurezza della compilazione non c'è molta differenza.
Tuttavia per gli oggetti Spied, il tipo di impostazione dello stub 'thenReturn' non funzionerà, poiché comporterà la chiamata del metodo reale prima che la risposta bloccata venga restituita come chiamata e non su un Mock, ma su Spy che avvolge un'istanza di oggetto reale .
Quindi supponiamo che ci sia una spia chiamata spiedObject e ha un metodo testMethod che restituisce un numero intero, quindi per impostare uno stub su questo dovrai usare doReturn invece di thenReturn.
doReturn (10).when(spiedObject.testMethod());D # 3) Quando e perché dovrebbe essere usata una spia?
Risposta: Spy è un tipo di mock parziale supportato da Mockito.
Ciò significa essenzialmente che è un tipo di istanza in cui:
per) Quando non è impostato alcun mock, qualsiasi interazione con la spia risulta nel chiamare i metodi reali. Ma ti consente comunque di verificare le interazioni con l'oggetto spiato come - è stato effettivamente chiamato un metodo, quante volte è stato chiamato il metodo, quali erano gli argomenti utilizzando i quali è stato chiamato il metodo, ecc.
b) Ti dà la flessibilità di impostare mock parziali.
Per esempio, se si dispone di un oggetto con 2 metodi: metodo1 e metodo2 e si desidera chiamare il metodo1 e deridere il metodo2. Le spie forniscono questo tipo di configurazione.
Quindi, la differenza tra un mock e uno stub in termini semplici è: un mock viene creato da un tipo e non da un'istanza mentre uno stub avvolge un'istanza effettiva dell'oggetto classe.
D # 4) Perché i metodi statici non possono essere derisi usando Mockito?
VPN per la Germania
Risposta: I metodi statici sono associati alla classe stessa e non a un'istanza particolare della classe. Ciò significa che tutte le istanze / oggetti della classe utilizzano la stessa istanza del metodo statico.
I metodi statici sono più simili al codice procedurale e sono usati principalmente nei sistemi legacy in generale.
Le librerie mock in genere creano mock mediante la creazione di istanze dinamiche in fase di esecuzione, tramite interfacce o ereditarietà e poiché il metodo statico non è associato a nessuna particolare istanza, non è possibile che i framework di mock (come mockito, easy mock, ecc.) Deridano i metodi statici.
Framework come PowerMock che supportano i metodi statici eseguono la manipolazione del bytecode in fase di esecuzione per simulare i metodi statici.
D # 5) Qual è la necessità di verificare che il mock è stato chiamato?
Risposta: L'impostazione di uno stub su un oggetto deriso (o un'istanza spiata) non garantisce se la configurazione bloccata è stata nemmeno invocata.
Abbinamenti di 'verifica', forniscono una funzione per convalidare se lo stub che è stato impostato è stato effettivamente richiamato o meno, quante volte è stata effettuata la chiamata, con quali argomenti è stato chiamato il metodo stub, ecc.
In sostanza, ci consente di verificare la configurazione del test e il risultato atteso in modo più affidabile.
Q # 6) Cos'è un buon codice testabile?
Risposta:
Alcuni punti sul codice testabile (significato che potrebbe essere facilmente testato in unità) includono:
- Numero ridotto di dipendenze o accoppiamento stretto - Esempio: Le dipendenze dovrebbero essere iniettate piuttosto che istanziate direttamente.
- Codice che aderisce a SRP (Single Responsibility Principle) - Ciò significa essenzialmente che la classe non dovrebbe avere più motivi per cambiare. L'adesione a SRP evita che le classi creino dipendenza da se stesse e mantiene il codice coerente e pulito.
- Utilizzo minimo / minimo di metodi statici e classi finali - Questi generalmente indicano odori di codice ed erano per lo più associati al codice legacy.
Q # 7) Quali sono i limiti di Mockito?
Risposta: Mockito è un framework di scelta per la maggior parte dei progetti basati su Java. È facile da implementare, leggere e capire.
Alcuni degli svantaggi o delle limitazioni in termini di funzionalità sono:
- La sua incapacità di deridere i metodi statici.
- Costruttori, metodi privati e classi finali non possono essere derisi.
D # 8) Quali framework possono supportare il mocking di metodi privati e statici?
Risposta: Framework come PowerMockito (estensioni del framework Mockito), JMockit, ecc. Forniscono mezzi per simulare metodi privati e statici.
D # 9) Metodi predefiniti di derisione / stubbing nell'interfaccia in Java 8.
Risposta: Con l'implementazione di Java 8 dei metodi predefiniti in Interface, Mockito fornisce supporto immediato per deridere tali metodi predefiniti. (Si prega di notare che questo supporto è stato introdotto da Mockito 2 in poi).
Questi metodi possono essere derisi / bloccati come qualsiasi altro metodo di una classe o interfaccia.
Q # 10) Come si può verificare l'ordine delle invocazioni degli stub in Mockito?
Risposta: Quando vuoi verificare l'ordine in cui sono stati chiamati i mock, Mockito ' Al fine ”Può essere utilizzata.
Durante il test, devi semplicemente impostare / creare un oggetto Inorder, elencando un elenco di oggetti fittizi su cui deve essere accertato l'ordine dei mock (se ci sono più metodi sullo stesso mock e non ci sono altri mock che necessitano per essere verificato è sufficiente citare la classe derisa una sola volta).
cos'è un buon servizio di posta elettronica
Considera il test fornito di seguito che definisce un oggetto di InOrder e menziona 2 occorrenze di mockDatabaseImpl
@Test public void calculateSumAndStore_withValidInput_verifyMockOrder() { // Arrange studentScores = new StudentScoreUpdates(mockDatabaseImpl); int() scores = {60,70,90}; Mockito.doNothing().when(mockDatabaseImpl).updateScores(anyString(), anyInt()); Mockito.doReturn('A').when(mockDatabaseImpl).getGrade(anyInt()); InOrder inorder = inOrder(mockDatabaseImpl); // Act studentScores.calculateSumAndStore('Student1', scores); // Assert inorder.verify(mockDatabaseImpl).updateScores(anyString(),anyInt()); inorder.verify(mockDatabaseImpl).getGrade(anyInt()); } Inoltre, per riferimento, elencare il codice del metodo sottoposto a test sarà utile per comprendere l'ordine di esecuzione del test:
public void calculateSumAndStore(String studentId, int() scores) { int total = 0; for(int score : scores) { total = total + score; } // write total to DB databaseImpl.updateScores(studentId, total); databaseImpl.getGrade(total); }Come visto sopra, databaseImpl chiama prima updateScores e poi getGrade.
Quindi, se stai scrivendo uno unit test usando Mockito, per questo e devi assicurarti l'ordine delle chiamate su databaseImpl, fai riferimento al codice del test e assicurati che le asserzioni siano fatte secondo l'ordine previsto.
Nell'esempio sopra, se cambio l'ordine delle affermazioni, il test fallirà con l'eccezione di 'VerificationInOrderFailure'.
Dopo aver modificato l'ordine di asserzione, il codice appare come mostrato di seguito:
@Test public void calculateSumAndStore_withValidInput_verifyMockOrder() { // Arrange studentScores = new StudentScoreUpdates(mockDatabaseImpl); int() scores = {60,70,90}; Mockito.doNothing().when(mockDatabaseImpl).updateScores(anyString(), anyInt()); Mockito.doReturn('A').when(mockDatabaseImpl).getGrade(anyInt()); InOrder inorder = inOrder(mockDatabaseImpl); // Act studentScores.calculateSumAndStore('Student1', scores); // Assert inorder.verify(mockDatabaseImpl).updateScores(anyString(),anyInt()); inorder.verify(mockDatabaseImpl).getGrade(anyInt()); } L'esecuzione del test sopra genera un'eccezione con tipo:
'VerificationInOrderFailure' org.mockito.exceptions.verification.VerificationInOrderFailure:
Verifica in caso di fallimento dell'ordine
Voluto ma non invocato:
mockDatabaseImpl.updateScores (
isA (java.lang.String),
isA (java.lang.Integer)
D # 11) Restituzione di più valori rispetto a chiamate di metodo consecutive
Risposta: Per restituire valori diversi per più invocazioni dello stesso metodo stubbed, Mockito fornisce 3 approcci come indicato di seguito:
per) Utilizzando separati da virgole: Funziona con thenReturn.
Per esempio , prendendo l'esempio di codice sopra, proviamo a impostare uno stub consecutivo per il metodo - getGrade che restituirà valori diversi a seconda della sequenza di iterazioni:
when (mockDatabaseImpl.getGrade( anyInt ())).thenReturn('A','B', 'C');Ciò significa che quando i metodi getGrade vengono chiamati nel metodo sotto test, la prima invocazione restituirà 'A', la seconda invocazione restituirà 'B' e così via.
b) Consecutivo poi Ritorno: Questo è un approccio che è concatenato con le istruzioni thenReturn. L'applicazione di chiamate concatenate allo stesso esempio apparirà come mostrato di seguito.
when (mockDatabaseImpl.getGrade( anyInt ())).thenReturn('A').thenReturn('B').thenReturn('C');c) Ritorno consecutivo: L'ultimo approccio sta usando doReturn nel formato concatenato come sopra.
doReturn ('A').doReturn('B').doReturn('C').when(mockDatabaseImpl).getGrade( anyInt ())D # 12) Quali sono i diversi tipi di framework di mocking e come funzionano?
Risposta: I tipi del framework Mocking e come funzionano sono spiegati di seguito.
Ci sono sostanzialmente 2 categorie di quadri beffardi:
- Basato su proxy - Esempio, Mockito, EasyMock, ecc.
- Basato su bytecode - Esempio, PowerMock, JMockit, ecc.
Confrontiamo entrambi questi framework su parametri diversi.
| Basato su proxy | Basato su bytecode | |
|---|---|---|
| In modo semplice | Più semplice e facile da usare | Potrebbe comportare una complessa logica di configurazione fittizia |
| Modalità di creazione | Viene creato un proxy o un oggetto falso che in realtà non richiede un'istanza di classe / interfaccia | Si tratta essenzialmente di creare oggetti e in fase di runtime manipola le istanze per il comportamento deriso / stubbed |
| Funzionalità | Classi e interfacce beffarde | Oltre a classi e interfacce, consente di deridere metodi statici, classi finali ecc |
| Dipendenza da Java | Non molto strettamente accoppiato alle versioni java | Poiché questi framework implicano la manipolazione del bytecode, sono strettamente collegati e potrebbero non essere compatibili con le versioni precedenti / successive tra le versioni java. |
| Esempi | Mockito, EasyMock ecc. | PowerMock, JMockit ecc. |
Conclusione
Il contenuto trattato in questo articolo serve discussioni di base sui framework Mocking e in particolare sulla preparazione dell'intervista a Mockito.
Oltre a ottenere una comprensione teorica delle domande trattate, si dovrebbe anche provare a fare esempi di codice reale che rendano l'apprendimento di questi framework più divertente e interessante.
Spero che l'intera gamma di tutorial di questa serie Mockito ti sia piaciuta.
Buon apprendimento.
Tutorial PREV | PRIMO Tutorial
Lettura consigliata
- Domande e risposte dell'intervista
- Tutorial Mockito: Mockito Framework per Mocking in Unit Testing
- Alcune interessanti domande di intervista sul test del software
- ETL Testing Interview Domande e risposte
- Principali domande per l'intervista su Oracle Forms and Reports
- Domande di intervista sul test manuale del software per professionisti esperti
- Principali domande di colloquio tecnico su Oracle Apps e Oracle SOA
- 25 migliori domande e risposte per l'intervista al test agile