top 12 mockito interview questions
Ofte stillede spørgsmål om Mockito-interview for at knække Mockito-latterlige interview:
I vores tidligere tutorial lærte vi Private, statiske og ugyldige metoder til hån . Læs gennem komplette træningsvejledninger om Mockito for en klar forståelse af Mockito-rammen.
Denne artikel dækker de mest hyppigt stillede typiske interviewspørgsmål om Mockito Mocking-rammen.
Enhver udvikler eller QA forventes at kende Mocking-grundlæggende for let at kunne skrive de mest hvide boks-test (eller enhedstest) og at spotte afhængighederne for forbedret kodedækning og større tillid til applikationen.
Mest populære Mockito Interview-spørgsmål med detaljerede svar
Nedenfor er de mest stillede spørgsmål om Mocking Frameworks.
Q # 1) Hvorfor har vi brug for hån?
Svar: Der er mange brugssager af spottende, der hjælper med enhedstest af koden under isolation og gør testen meget gentagelig og forudsigelig.
Mocking er generelt påkrævet, når:
til) Komponenten under test har afhængigheder, der endnu ikke er implementeret, eller implementeringen er i gang.
Et godt eksempel kan være et REST API-slutpunkt, som vil være tilgængeligt senere på et tidspunkt, men du har brugt det i koden via en afhængighed.
Nu da den rigtige implementering stadig ikke er tilgængelig, ved du virkelig det meste af tiden, hvad det forventede svar fra den API er. Mocks giver dig mulighed for at teste den slags integration.
b) Komponent opdaterer tilstanden i systemet.
Eksempel: DB-opkald - du vil ikke opdatere din DB med data, der kun er til testformål. Dette kan resultere i ødelæggelse af dataene. Desuden er tilgængeligheden af DB en anden udfordring, når testen udføres.
For at undgå en sådan adfærd kunne DB-opkald bespottes i den komponent, der testes. Derfor er der ingen direkte kobling af DB og komponenten under test.
Q # 2) Forskel mellem doReturn og derefterReturn.
Svar: Mockito giver to forskellige syntakser til oprettelse af stubs som:
- doReturn og derefterReturn
- gør intet (ikke da intet)
- doTrow og derefter kast
Begge disse metoder opsætter stubber og kan bruges til at oprette / opsætte stubber og kan til tider bruges om hverandre.
god mp3 downloader til android gratis
Så hvordan adskiller begge disse sig?
til) Den derefter Retur-måde at stubbe på er en typesikker måde at oprette stubbe på. Hvad dette i det væsentlige betyder er, at det foretager en kompileringstidskontrol mod de returtyper, som du også vil stubbe.
Lad os forstå dette med et eksempel:
Antag en metode getItemDetails på mockedItemService som returnerer et objekt af typen ItemSku. Så med derefter Retur, du kan ikke returnere andet end typen ItemSku, men med doReturn kan du indstille stubben til at returnere noget, og testen mislykkes (eller kaster en undtagelse) under udførelsen.
// arbejder
when (mockedItemService.getItemDetails(123)).thenReturn(new ItemSku());// kaster kompileringstidsundtagelse
when (mockedItemService.getItemDetails(123)).thenReturn(expectedPrice);// med doReturn fungerer både stubopsætningen, da den ikke er kompileret sikker.
// her forsøger vi at returnere et objekt af typen dobbelt, som stadig fungerer og ikke kaster nogen kompileringstidsadvarsel.
doReturn (expectedPrice).when(mockedItemService.getItemDetails(123)); doReturn (new ItemSku()).when(mockedItemService.getItemDetails(123));b) En anden vigtig forskel mellem disse 2 måder til stubben er for Mocked objekter, bortset fra kompileringssikkerhed er der ikke meget forskel.
Men for spionerede objekter fungerer 'thenReturn' -formen for stub ikke, da det vil resultere i at kalde den rigtige metode, før det stubbed-svar returneres som opkaldet og ikke på en Mock, men på Spy, der indpakker en reel objektforekomst .
Så antag, der er en spion ved navn spiedObject, og den har en metodetestMetode, der returnerer et heltal, og derefter skal du bruge doReturn i stedet for thenReturn for at opsætte en stub på dette.
doReturn (10).when(spiedObject.testMethod());Spørgsmål nr. 3) Hvornår og hvorfor skal en spion bruges?
Svar: Spy er en type delvis mock understøttet af Mockito.
Dette betyder i det væsentlige er en type instans, hvor:
til) Når der ikke er oprettet nogen mock, resulterer enhver interaktion på spion i at kalde de rigtige metoder. Men det giver dig stadig mulighed for at kontrollere interaktionerne med det spionerede objekt som - var en metode, der faktisk blev kaldt, hvor mange gange metoden blev kaldt, hvad var de argumenter, som metoden blev kaldt osv.
b) Det giver dig fleksibilitet til at oprette delvise mocks.
For eksempel, hvis du har et objekt med to metoder - metode1 og metode2, og du ønsker, at metode1 skal kaldes, og metode2 bespottes. Spioner leverer denne form for opsætning.
Så forskellen mellem en mock og en stub i enkle vendinger er - en mock oprettes fra en type og ikke fra en instans, mens en stub indpakker en faktisk forekomst af klasseobjektet.
Spørgsmål nr. 4) Hvorfor kan der ikke spottes med statiske metoder ved hjælp af Mockito?
cirkulær sammenkædet liste c ++
Svar: Statiske metoder er forbundet med selve klassen og ikke nogen særlig forekomst af klassen. Dette betyder, at alle forekomster / objekter i klassen bruger den samme forekomst af den statiske metode.
Statiske metoder ligner mere procedurekode og bruges mest i ældre systemer generelt.
Mock-biblioteker opretter typisk mocks ved oprettelse af dynamisk forekomst ved kørsel, enten gennem grænseflader eller gennem arv, og da den statiske metode ikke er forbundet med en bestemt forekomst, er det ikke muligt for mocking-rammer (som mockito, let mock osv.) At spotte statiske metoder.
Rammer som PowerMock, der understøtter statiske metoder, udfører manipulation af kodekoder ved kørsel for at spotte statiske metoder.
Spørgsmål nr. 5) Hvad er behovet for at kontrollere, at mocken blev kaldt?
Svar: Opsætning af en stub på et spottet objekt (eller en spioneret instans) garanterer ikke, om den stubede opsætning overhovedet blev påberåbt.
”Verifikations” matchere, giv en mulighed for at validere, om den stub, der blev oprettet, faktisk blev påkaldt eller ej, hvor mange gange blev opkaldet foretaget, hvilke argumenter blev den stubede metode kaldet med osv.
I det væsentlige giver det os mulighed for at verificere testopsætningen og det forventede resultat på en mere robust måde.
Q # 6) Hvad er en god testbar kode?
Svar:
Få punkter omkring testbar kode (hvilket betyder, at det let kunne testes enhed) inkluderer:
- Reduceret antal afhængigheder eller tæt kobling - Eksempel: Afhængigheder skal injiceres snarere end instanteres direkte.
- Kode, der overholder SRP (Single Responsibility Principle) - Dette betyder i det væsentlige, at klassen ikke skal have flere grunde til at ændre sig. Overholdelse af SRP undgår klasser, der skaber afhængighed af sig selv og holder koden sammenhængende og ren.
- Mindre / minimal brug af statiske metoder og afsluttende klasser - Disse indikerer generelt kodelugt og var for det meste forbundet med den ældre kode.
Spørgsmål nr. 7) Hvad er begrænsningerne ved Mockito?
Svar: Mockito er en valgfri ramme for de fleste af de java-baserede projekter. Det er let at implementere, læse og forstå.
Nogle af ulemperne eller begrænsningerne med hensyn til funktionalitet er:
- Dens manglende evne til at spotte statiske metoder.
- Konstruktører, private metoder og afsluttende klasser kan ikke bespottes.
Spørgsmål nr. 8) Hvilke rammer kan understøtte hån mod private og statiske metoder?
Svar: Rammer som PowerMockito (udvidelser af Mockito framework), JMockit osv. Giver faktisk midler til at spotte private og statiske metoder.
Q # 9) Mocking / Stubbing standardmetoder i Interface i Java 8.
Svar: Med Java 8's implementering af standardmetoder i Interface giver Mockito out-of-box support til at spotte sådanne standardmetoder. (Bemærk, at denne support blev introduceret fra Mockito 2 og fremefter).
Disse metoder kan bespottes / stubbes som alle andre metoder i en klasse eller grænseflade.
Spørgsmål nr. 10) Hvordan kan rækkefølgen af stubindkaldelser verificeres i Mockito?
Svar: Når du vil bekræfte den rækkefølge, som mocks blev kaldt i, er Mockitos ' Bestil ”Interface kan bruges.
Under testen skal du simpelthen opsætte / oprette et Inorder-objekt, der viser en liste over mock-objekter, som rækkefølgen af mocks skal undersøges i (hvis der er flere metoder på den samme mock, og der ikke er nogen anden mock, der har brug for for at blive verificeret, så er det tilstrækkeligt at kun nævne den hånede klasse en gang).
Overvej nedenstående test, der definerer et objekt med InOrder og nævner 2 forekomster af mockDatabaseImpl
venstre indre sammenføjning mod venstre ydre sammenføjning
@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()); } Som reference kan det være nyttigt at forstå rækkefølgen af testudførelse ved at notere koden for den metode, der testes:
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); }Som set ovenfor kalder databaseImpl først updateScores og derefter opkald til getGrade.
Så hvis du skriver en enhedstest ved hjælp af Mockito, skal du til dette, og du skal sikre rækkefølgen af opkaldene på databaseImpl, henvise til testkoden og sikre, at erklæringerne foretages i henhold til den forventede ordre.
I ovenstående eksempel, hvis jeg ændrer rækkefølgen af asserts, vil det medføre, at testen mislykkes med undtagelse af 'VerificationInOrderFailure'.
Efter ændring af påstået rækkefølge ser koden ud som vist nedenfor:
@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()); } Ovenstående testudførelse kaster en undtagelse med typen:
“VerificationInOrderFailure” org.mockito.exceptions.verification.VerificationInOrderFailure:
Bekræftelse af ordrefejl
Ønsket men ikke påberåbt:
mockDatabaseImpl.updateScores (
isA (java.lang.String),
isA (java.lang.Integer)
Q # 11) Returnering af flere værdier mod på hinanden følgende metodeopkald
Svar: For at returnere forskellige værdier for flere påkald af den samme stubede metode, giver Mockito 3 tilgange som angivet nedenfor:
til) Brug kommasepareret: Dette fungerer med thenReturn.
For eksempel , tager ovenstående kodeeksempel, lad os prøve at konfigurere fortløbende stub til metode - getGrade, som returnerer forskellige værdier afhængigt af rækkefølgen af iterationer:
when (mockDatabaseImpl.getGrade( anyInt ())).thenReturn('A','B', 'C');Dette betyder, at når getGrade-metoder bliver kaldt i metoden under test, returnerer den første påkaldelse 'A', den anden påkaldelse returnerer 'B' og så videre.
b) Fortløbende derefter Retur: Dette er en tilgang, der er lænket med dengang Retur-udsagn. Anvendelse af kædede opkald til det samme eksempel ser ud som vist nedenfor.
when (mockDatabaseImpl.getGrade( anyInt ())).thenReturn('A').thenReturn('B').thenReturn('C');c) Efterfølgende doReturn: Den sidste tilgang er at bruge doReturn i det kædede format som ovenfor.
doReturn ('A').doReturn('B').doReturn('C').when(mockDatabaseImpl).getGrade( anyInt ())Spørgsmål nr. 12) Hvad er de forskellige typer spottende rammer, og hvordan fungerer de?
Svar: Typer af Mocking-rammen, og hvordan de fungerer, forklares nedenfor.
Der er stort set to kategorier af spottende rammer:
- Proxy-baseret - Eksempel, Mockito, EasyMock osv.
- Bytecode-baseret - Eksempel, PowerMock, JMockit osv.
Lad os sammenligne begge disse rammer på forskellige parametre.
| Proxy-baseret | Bytecode-baseret | |
|---|---|---|
| Simpelt | Mere enkel og nem at bruge | Kan involvere kompliceret logisk opsætningslogik |
| Skabelsesmetode | Der oprettes en proxy eller et falsk objekt, der faktisk ikke kræver forekomst af klasse / interface | Det involverer i det væsentlige at oprette objekter og manipulerer i runtime forekomsterne for den spottede / stubede opførsel |
| Funktionalitet | Spottende klasser og grænseflader | Foruden klasser og grænseflader tillader det at spotte statiske metoder, afsluttende klasser osv |
| Java-afhængighed | Ikke meget tæt koblet til java-versioner | Da disse rammer indebærer manipulation af bytecode, er de tæt koblet og er muligvis ikke bagud / fremad kompatible på tværs af java-versioner. |
| Eksempler | Mockito, EasyMock osv. | PowerMock, JMockit osv. |
Konklusion
Indholdet, der er dækket af denne artikel, tjener grundlæggende diskussioner omkring Mocking-rammer og specifikt Mockito-interviewforberedelse.
Ud over at få en teoretisk forståelse af de dækkede spørgsmål, bør man også prøve at lave rigtige kodeeksempler, der gør indlæring af disse rammer mere sjov og interessant.
Håber, du nød hele rækken af tutorials i denne Mockito-serie.
Glad læring.
PREV-vejledning | FØRSTE vejledning
Anbefalet læsning
- Interviewspørgsmål og svar
- Mockito Tutorial: Mockito Framework for Mocking i Unit Testing
- Nogle interessante softwaretestinterviewspørgsmål
- ETL Testing Interview Spørgsmål og svar
- Top spørgsmål om Oracle-formularer og rapporter
- Software manuel test Interviewspørgsmål til erfarne fagfolk
- Top Oracle Apps tekniske og Oracle SOA interviewspørgsmål
- 25 bedste spørgsmål og svar til interview med Agile Testing