Mockito-ramverket tillhandahåller en mängd olika metoder som mock(), verify(), when(), etc., som används för att testa Java-applikationer. Att använda dessa fördefinierade metoder gör testningen mycket enkel.

Den korta beskrivningen av Mockito-metoderna ges nedan:

minnesbyte

Mockito mock() metod

Den används för att skapa skenobjekt av en given klass eller gränssnitt. Mockito innehåller fem falsk() metoder med olika argument. När vi inte tilldelade något till hånar kommer de att returnera standardvärden. Alla fem metoderna utför samma funktion att håna objekten.

Följande är mock()-metoderna med olika parametrar:

mock() metod med klass:Den används för att skapa skenobjekt av en konkret klass eller ett gränssnitt. Det tar en klass eller ett gränssnittsnamn som parameter.
Syntax: mock(Class classToMock)mock() metod med svar:Det används för att skapa skenobjekt av en klass eller gränssnitt med en specifik procedur. Det är en avancerad mock-metod som kan användas när man arbetar med äldre system. Det tar Answer som en parameter tillsammans med klassens eller gränssnittsnamnet. Svaret är en uppräkning av förkonfigurerade skensvar.
Syntax: mock(Class classToMock, Answer defaultAnswer)mock() metod med MockSettings:Den används för att skapa skenobjekt med vissa icke-standardinställningar. Det tar MockSettings som en extra inställningsparameter tillsammans med klass- eller gränssnittsnamnet. MockSettings tillåter skapandet av skenobjekt med ytterligare inställningar.
Syntax: mock(Class classToMock, MockSettings mockSettings)mock() metod med ReturnValues:Det tillåter skapandet av skenobjekt av en given klass eller gränssnitt. Nu är den utfasad, eftersom ReturnValues ​​ersätts med Answer.
Syntax: mock(Class classToMock, ReturnValues ​​returnValues)mock() metod med String:Den används för att skapa skenobjekt genom att ange skennamnen. Vid felsökning kan det vara till hjälp att namnge skenobjekt medan det är ett dåligt val med stor och komplex kod.
Syntax: mock(Class classToMock, String name)

Följande kodavsnitt visar hur du använder falsk() metod:

 ToDoService doService = mock(ToDoService.class); 

Mockito when()-metoden

Det möjliggör stubbningsmetoder. Det bör användas när vi vill håna för att returnera specifika värden när särskilda metoder anropas. I enkla termer, ' När metoden XYZ() kallas, sedan returnera ABC.' Det används mest när det finns något villkor att utföra.

Syntax: när(T methodCall)

Följande kodavsnitt visar hur man använder metoden when():

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

I ovanstående kod, thenReturn() används mest med när() metod.

Mockito verify() metod

De kontrollera() metod används för att kontrollera om vissa angivna metoder anropas eller inte. Enkelt uttryckt validerar det det specifika beteendet som hände en gång i ett test. Den används längst ner i testkoden för att säkerställa att de definierade metoderna anropas.

Mockito-ramverket håller reda på alla metodanrop med deras parametrar för att håna objekt. Efter hån kan vi verifiera att de definierade villkoren är uppfyllda eller inte genom att använda metoden verify(). Denna typ av testning kallas ibland beteendetestning. Den kontrollerar att en metod anropas med rätt parametrar istället för att kontrollera resultatet av ett metodanrop.

Metoden verify() används också för att testa antalet anrop. Så vi kan testa det exakta antalet anrop genom att använda gånger metod, minst en gång metod, och på sin höjd metod för en hånad metod.

Det finns två typer av verify()-metoder tillgängliga i Mockito-klassen, som anges nedan:

verify() metod:Det verifierar att visst beteende har hänt en gång.
Syntax: verifiera (T håna)verify() metod med VerificationMode:Det verifierar att något beteende har inträffat minst en gång, exakt antal gånger eller aldrig.
Syntax: verifiera (T mock, VerificationMode-läge)

Mockito spy() metod

Mockito tillhandahåller en metod för att delvis håna ett objekt, vilket är känt som spionera metod. När du använder spionmetoden finns det ett verkligt objekt, och spioner eller stubbar skapas av det verkliga objektet. Om vi ​​inte stoppar en metod med spion kommer den att kalla det verkliga metoden beteende. Huvudfunktionen för metoden spy() är att den åsidosätter de specifika metoderna för det verkliga objektet. En av funktionerna hos metoden spy() är att den verifierar anropet av en viss metod.

Det finns två typer av spy()-metoder tillgängliga i Mockito-klassen:

spy() metod:Det skapar en spion av det verkliga föremålet. Spionmetoden kallar de riktiga metoderna om de inte är stubbade. Vi bör använda de riktiga spionerna försiktigt och då och då, till exempel när vi hanterar den äldre koden.
Syntax: spion(T-objekt)spy() metod med klass:Den skapar ett spionobjekt baserat på klass istället för ett objekt. Metoden spy(T object) är särskilt användbar för att spionera abstrakta klasser eftersom de inte kan instansieras.
Syntax: spion(Class classToSpy)

Följande kodavsnitt visar hur du använder metoden spy():

 List spyArrayList = spy(ArrayList.class); 

Mockito reset() metod

Metoden Mockito reset() används för att återställa mockarna. Den används främst för att arbeta med behållaren injicerade mocks. Vanligtvis resulterar metoden reset() i en lång kod och dåliga tester. Det är bättre att skapa nya hån istället för att använda metoden reset(). Det är därför som metoden reset() sällan används vid testning.

Signaturen för metoden reset() är:

anropar js-funktionen från html

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

Mockito verifyNoMoreInteractions()-metoden

Den används för att kontrollera att någon av de givna hånarna har några overifierade interaktioner. Vi kan använda den här metoden efter att ha verifierat alla mockar, för att säkerställa att inget annat anropades på mockarna. Den upptäcker också de overifierade anropen som förekommer före testmetoden, till exempel i setup(), @Before-metoden eller konstruktorn. Det är en valfri metod och vi behöver inte använda den i varje test.

Signaturen för metoden verifyNoMoreInteractions() är:

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

Mockito verifyZeroInteractions() metod

Den verifierar att ingen interaktion har inträffat på de givna hånarna. Den upptäcker också anrop som har inträffat före testmetoden, till exempel i setup(), @Before-metoden eller konstruktorn.

Signaturen för metoden verifyZeroInteractions() är:

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

Mockito doThrow() metod

Det används när man ska stoppa en void-metod för att kasta ett undantag. Det skapar en ny undantagsinstans för varje metodanrop. Det finns två typer av doThrow()-metoder tillgängliga i klassen Mockito med olika parametrar, som visas nedan:

doThrow()-metoden med Throwable:Denna metod används när vi vill stoppa en void-metod med ett undantag. Syntax: doThrow(Skastbar för att BeThrown)
Signaturen för metoden doThrow() är:

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

doThrow() metod med klass:Denna metod används när vi vill stubba en void-metod för att kasta ett undantag för en specificerad klass.
Syntax: doThrow(Class toBeThrown)
Signaturen för metoden doThrow() är:

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

Mockito doCallRealMethod() metod

Det används när vi vill kalla den verkliga implementeringen av en metod. Med andra ord, det används för att skapa partiella hånar av ett objekt. Det används i sällsynta situationer, som att kalla de verkliga metoderna. Den liknar metoden spy() och den enda skillnaden är att den resulterar i komplex kod.

Signaturen för metoden doCallRealMethod() är:

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

Mockito doAnswer()-metoden

Den används när vi vill stoppa en void-metod med en generisk svarstyp. Signaturen för metoden doAnswer() är:

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

Mockito doNothing()-metoden

Den används för att ställa in void-metoder att inte göra någonting. Metoden doNothing() används i sällsynta situationer. Som standard gör void-metoderna på falska instanser ingenting, d.v.s. ingen uppgift utförs.

stack java

Signaturen för metoden doNothing() är:

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

Mockito doReturn() metod

Det används vid de sällsynta tillfällen då vi inte kan använda Mockito.when(object). Metoden Mockito.when(object) föreslås alltid för stubbning eftersom den är argumenttypsäker och mer läsbar jämfört med doReturn()-metoden.

Signaturen för metoden doReturn() är:

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

Mockito inOrder() metod

Det används för att skapa objekt som tillåter verifiering av hånar i en specifik ordning. Verifiering som görs i ordning är mer flexibel eftersom vi inte behöver verifiera alla interaktioner. Vi behöver bara verifiera de interaktioner som är intresserade av att testa (i ordning). Vi kan också använda metoden inOrder() för att skapa ett inOrder-objekt som skickar hån som är relevanta för in-order-verifiering.

Signaturen för metoden Mockito.inOrder() är:

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

Mockito ignoreStubs() metod

Det används för att ignorera de stubbade metoderna för givna hån för verifiering. Det är användbart med metoderna verifyNoMoreInteractions() eller verifiering inOrder(). Det hjälper också till att undvika redundant verifiering av stubbade samtal.

Signaturen för metoden ignoreStubs() är:

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

Mockito times() metod

Den används för att verifiera det exakta antalet metodanrop, vilket innebär att den deklarerar hur många gånger en metod anropas. Signaturen för times()-metoden är:

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

Mockito never()-metoden

Den används för att verifiera att interaktionen inte inträffade. Signaturen för metoden never() är:

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

Mockito atLeastOnce() metod

Den används för att verifiera anropet åtminstone en gång, vilket innebär att metoden bör anropas minst en gång.

Signaturen för metoden atLeastOnce() är:

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

Mockito atLeast()-metoden

Den används för att verifiera anropet minst x antal gånger. Till exempel, givet minst(3) betyder att metoden kommer att anropa minst tre gånger.

Signaturen för metoden atLeast() är:

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

Mockito atMost() metod

Den används för att verifiera anropet högst x antal gånger. Till exempel, given atMost(3) betyder att metoden kommer att anropa maximalt tre gånger.

Signaturen för metoden atMost() är:

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

Mockito calls() metod

Det tillåter en icke-girig verifiering i ordning. Den kan endast användas med verifieringsmetoden inOrder(). Till exempel, inOrder.verify(mock, calls(3)).xyzMethod('...');

Signaturen för metoden calls() är:

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

Mockito only() metod

Den kontrollerar att den givna metoden var den enda anropade metoden. Signaturen för metoden only() är:

operatörer inom python-programmering

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

Mockito timeout() metod

Det tillåter Mockito att utföra verifiering med en timeout. Den instruerar en verifiering att vänta en viss tidsperiod på en viss interaktion snarare än att misslyckas omedelbart. Det kan vara användbart för att testa i befintliga situationer.

Timeout()-metoden skiljer sig från after()-metoden eftersom after()-metoden väntar på hela perioden såvida inte det slutliga resultatet deklareras medan timeout()-metoden stoppas så snart verifieringen passerar. Det används sällan i tester.

Signaturen för metoden timeout() är:

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

Mockito after() metod

Det tillåter Mockito att verifiera över en viss tidsperiod. Vi har redan diskuterat att metoden after() skiljer sig från metoden timeout().

Signaturen för metoden after() är:

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

Mockito validateMockitoUsage()-metoden

Den används för att explicit validera ramtillståndet för att upptäcka den ogiltiga användningen av Mockito-ramverket. Det är en valfri funktion i Mockito eftersom den validerar användningen hela tiden. Både den inbyggda löparen (MockitoJUnitRunner) och regeln (MockitoRule) anropar metoden validateMockitoUsage() efter varje testmetod.

Signaturen för metoden validateMockitoUsage() är:

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

Mockito withSettings()-metoden

Den används för att skapa mockar med ytterligare mock-inställningar. Den bör användas då och då vid testning. Istället för att använda metoden withSettings() skapar du enkla tester med enkla hån. De främsta anledningarna till att använda MockSettings är

• Genom att använda MockSetting kan vi enkelt lägga till andra skeninställningar när det behövs.
• Den kombinerar olika skeninställningar utan att förstöra koden.

Signaturen för metoden withSettings() är:

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