El framework Mockito proporciona una varietat de mètodes com mock(), verify(), when(), etc., utilitzats per provar aplicacions Java. L'ús d'aquests mètodes predefinits fa que les proves siguin molt fàcils.

A continuació es presenta una breu descripció dels mètodes Mockito:

crear fil java

Mètode mockito mock().

S'utilitza per crear objectes simulats d'una classe o interfície determinada. Mockito en conté cinc burla () mètodes amb diferents arguments. Quan no hem assignat res als simulacres, tornaran els valors per defecte. Els cinc mètodes fan la mateixa funció de burlar-se dels objectes.

A continuació es mostren els mètodes mock() amb diferents paràmetres:

mètode mock() amb Class:S'utilitza per crear objectes simulats d'una classe concreta o una interfície. Pren com a paràmetre una classe o un nom d'interfície.
Sintaxi: simulacre (classe de classeToMock)mètode mock() amb Resposta:S'utilitza per crear objectes simulats d'una classe o interfície amb un procediment específic. És un mètode simulat avançat, que es pot utilitzar quan es treballa amb sistemes heretats. Pren Resposta com a paràmetre juntament amb el nom de la classe o de la interfície. La resposta és una enumeració de respostes simulades preconfigurades.
Sintaxi: mock (classe de classeToMock, Resposta per defecte)mètode mock() amb MockSettings:S'utilitza per crear objectes simulats amb algunes configuracions no estàndard. Pren MockSettings com a paràmetre de configuració addicional juntament amb el nom de la classe o la interfície. MockSettings permet la creació d'objectes simulats amb paràmetres addicionals.
Sintaxi: simulacre (classe de classeToMock, MockSettings mockSettings)mètode mock() amb ReturnValues:Permet la creació d'objectes simulats d'una classe o interfície determinada. Ara, està obsolet, ja que ReturnValues ​​es substitueixen per Answer.
Sintaxi: mock(Classe de classeToMock, ReturnValues ​​returnValues)mètode mock() amb String:S'utilitza per crear objectes simulats especificant els noms simulats. A la depuració, anomenar objectes simulats pot ser útil, mentre que és una mala elecció utilitzar-los amb codi gran i complex.
Sintaxi: mock (classe de classeToMock, nom de cadena)

El fragment de codi següent mostra com utilitzar-lo burla () mètode:

 ToDoService doService = mock(ToDoService.class); 

Mètode Mockito quan().

Permet mètodes de tall. S'ha d'utilitzar quan volem burlar-nos per retornar valors específics quan es criden a mètodes concrets. En termes senzills, ' Quan el mètode XYZ() s'anomena, aleshores torna ABC.' S'utilitza principalment quan hi ha alguna condició per executar.

Sintaxi: quan(T methodCall)

El següent fragment de codi mostra com utilitzar el mètode when():

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

En el codi anterior, thenReturn() s'utilitza principalment amb el Quan() mètode.

Mètode Mockito verifica().

El verificar () El mètode s'utilitza per comprovar si es criden o no alguns mètodes especificats. En termes simples, valida el comportament determinat que va passar una vegada en una prova. S'utilitza a la part inferior del codi de prova per assegurar que es criden els mètodes definits.

El marc de Mockito fa un seguiment de totes les trucades de mètodes amb els seus paràmetres per burlar objectes. Després de burlar-nos, podem comprovar que les condicions definides es compleixen o no mitjançant el mètode verify(). Aquest tipus de proves de vegades es coneix com proves de comportament. Comprova que un mètode es crida amb els paràmetres correctes en lloc de comprovar el resultat d'una trucada de mètode.

El mètode verify() també s'utilitza per provar el nombre d'invocacions. Així que podem provar el nombre exacte d'invocacions mitjançant l' mètode de vegades, mètode almenys una vegada, i com a molt mètode per un mètode burlat.

Hi ha dos tipus de mètodes verifica() disponibles a la classe Mockito, que es donen a continuació:

mètode de verificació ():Verifica que un determinat comportament s'ha produït una vegada.
Sintaxi: verificar (T burla)mètode verify() amb VerificationMode:Verifica que algun comportament hagi passat almenys una vegada, el nombre exacte de vegades o mai.
Sintaxi: verificar (T mock, mode VerificationMode)

Mètode Mockito spy().

Mockito proporciona un mètode per burlar parcialment un objecte, que es coneix com a espia mètode. Quan s'utilitza el mètode d'espionatge, hi ha un objecte real i es creen espies o talons d'aquest objecte real. Si no interrompem un mètode amb espia, anomenarà el comportament del mètode real. La funció principal del mètode spy() és que anul·la els mètodes específics de l'objecte real. Una de les funcions del mètode spy() és verificar la invocació d'un mètode determinat.

Hi ha dos tipus de mètodes spy() disponibles a la classe Mockito:

Mètode espia():Crea un espia de l'objecte real. El mètode d'espionatge crida als mètodes reals, tret que estiguin intercalats. Hauríem d'utilitzar els espies reals amb cura i ocasionalment, per exemple, quan tractem amb el codi heretat.
Sintaxi: espia (objecte T)mètode spy() amb Class:Crea un objecte espia basat en classe en lloc d'un objecte. El mètode spy(T object) és especialment útil per espiar classes abstractes perquè no es poden instanciar.
Sintaxi: espia (classe de classeToSpy)

El següent fragment de codi mostra com utilitzar el mètode spy():

 List spyArrayList = spy(ArrayList.class); 

Mètode Mockito reset().

El mètode Mockito reset() s'utilitza per restablir els simulacres. S'utilitza principalment per treballar amb maquetes injectades en contenidors. Normalment, el mètode reset() dóna com a resultat un codi llarg i proves deficients. És millor crear noves simulacions en lloc d'utilitzar el mètode reset(). És per això que el mètode reset() rarament s'utilitza a les proves.

La signatura del mètode reset() és:

quina diferència hi ha entre un megabyte i un gigabyte

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

Mockito verifica el mètode NoMoreInteractions().

S'utilitza per comprovar que qualsevol dels simulacres donats té interaccions no verificades. Podem utilitzar aquest mètode després de verificar totes les maquetes, per assegurar-nos que no s'ha invocat res més a les maquetes. També detecta les invocacions no verificades que es produeixen abans del mètode de prova, per exemple, al mètode setup(), @Before o al constructor. És un mètode opcional i no cal que l'utilitzem en totes les proves.

La signatura del mètode verifyNoMoreInteractions() és:

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

Mockito verifica el mètode ZeroInteractions().

Verifica que no s'ha produït cap interacció amb els simulacres donats. També detecta les invocacions que s'han produït abans del mètode de prova, per exemple, al mètode setup(), @Before o al constructor.

La signatura del mètode verifyZeroInteractions() és:

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

Mètode Mockito doThrow().

S'utilitza quan s'aplica un mètode de buit per llançar una excepció. Crea una nova instància d'excepció per a cada invocació de mètode. Hi ha dos tipus de mètodes doThrow() disponibles a la classe Mockito amb diferents paràmetres, com es mostra a continuació:

Mètode doThrow() amb Throwable:Aquest mètode s'utilitza quan volem eliminar un mètode buit amb una excepció. Sintaxi: doThrow (Llançable per a ser llançat)
La signatura del mètode doThrow() és:

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

Mètode doThrow() amb Class:Aquest mètode s'utilitza quan volem esborrar un mètode void per llançar una excepció d'una classe especificada.
Sintaxi: doThrow (Classe per llançar)
La signatura del mètode doThrow() és:

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

Mockito mètode doCallRealMethod().

S'utilitza quan volem cridar la implementació real d'un mètode. En altres paraules, s'utilitza per crear simulacres parcials d'un objecte. S'utilitza en situacions rares, com ara per cridar els mètodes reals. És similar al mètode spy() i l'única diferència és que resulta en codi complex.

La signatura del mètode doCallRealMethod() és:

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

Mètode Mockito doAnswer().

S'utilitza quan volem tallar un mètode de buit amb un tipus de resposta genèric. La signatura del mètode doAnswer() és:

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

Mètode Mockito doNothing().

S'utilitza per configurar mètodes buits per no fer res. El mètode doNothing() s'utilitza en situacions excepcionals. De manera predeterminada, els mètodes nuls de les instàncies simulades no fan res, és a dir, no es realitza cap tasca.

La signatura del mètode doNothing() és:

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

Mètode Mockito doReturn().

S'utilitza en aquelles rares ocasions en què no podem utilitzar Mockito.when(object). El mètode Mockito.when(object) sempre es recomana per a l'estub perquè és segur per al tipus d'argument i és més llegible en comparació amb el mètode doReturn().

diana mary blacker

La signatura del mètode doReturn() és:

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

Mètode Mockito inOrder().

S'utilitza per crear objectes que permeten la verificació de simulacres en un ordre concret. La verificació feta per ordre és més flexible, ja que no hem de verificar totes les interaccions. Hem de verificar només aquelles interaccions que estan interessades a provar (en ordre). També podem utilitzar el mètode inOrder() per crear un objecte inOrder passant simulacres que són rellevants per a la verificació de l'ordre.

La signatura del mètode Mockito.inOrder() és:

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

Mètode Mockito ignoreStubs().

S'utilitza per ignorar els mètodes tallats dels simulacres donats per a la verificació. És útil amb els mètodes verifyNoMoreInteractions() o verification inOrder(). També ajuda a evitar la verificació redundant de trucades interceptades.

La signatura del mètode ignoreStubs() és:

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

Mètode Mockito times().

S'utilitza per verificar el nombre exacte d'invocacions de mètodes, el que significa que declara quantes vegades s'invoca un mètode. La signatura del mètode times() és:

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

Mètode Mockito never().

S'utilitza per comprovar que la interacció no s'ha produït. La signatura del mètode never() és:

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

Mètode Mockito atLeastOnce().

S'utilitza per verificar la invocació almenys una vegada, això significa que el mètode s'ha d'invocar almenys una vegada.

La signatura del mètode atLeastOnce() és:

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

Mètode Mockito almenys ().

S'utilitza per verificar la invocació almenys x vegades. Per exemple, donat com a mínim (3) significa que el mètode invocarà un mínim de tres vegades.

La signatura del mètode atLeast() és:

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

Mètode Mockito atMost().

S'utilitza per verificar la invocació com a màxim x vegades. Per exemple, donat atMost(3) significa que el mètode invocarà un màxim de tres vegades.

La signatura del mètode atMost() és:

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

El mètode Mockito crida ().

Permet una verificació no avaricia en ordre. Només es pot utilitzar amb el mètode de verificació inOrder(). Per exemple, inOrder.verify(mock, calls(3)).xyzMethod('...');

La signatura del mètode calls() és:

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

Mètode Mockito only().

Comprova que el mètode donat era l'únic mètode invocat. La signatura del mètode only() és:

farciment css

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

Mètode Mockito timeout().

Permet a Mockito realitzar la verificació amb un temps d'espera. Indica a una verificació que esperi un període de temps específic per a una interacció concreta en lloc de fallar immediatament. Pot ser útil per fer proves en situacions existents.

El mètode timeout() difereix del mètode after() ja que el mètode after() espera durant tot el període tret que es declari el resultat final, mentre que el mètode timeout() s'aturarà tan bon punt passi la verificació. Poques vegades s'utilitza en proves.

La signatura del mètode timeout() és:

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

Mètode Mockito after().

Permet a Mockito verificar durant un període de temps determinat. Ja hem comentat que el mètode after() és diferent del mètode timeout().

La signatura del mètode after() és:

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

Mockito validateMockitoUsage() mètode

S'utilitza per validar explícitament l'estat del marc per detectar l'ús no vàlid del marc Mockito. És una característica opcional de Mockito perquè valida l'ús tot el temps. Tant el corredor integrat (MockitoJUnitRunner) com la regla (MockitoRule) criden al mètode validateMockitoUsage() després de cada mètode de prova.

La signatura del mètode validateMockitoUsage() és:

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

Mockito amb el mètode Settings().

S'utilitza per crear simulacres amb paràmetres de simulació addicionals. S'ha d'utilitzar ocasionalment en proves. En lloc d'utilitzar el mètode withSettings(), creeu proves senzilles amb simulacions simples. Els motius principals per utilitzar MockSettings són

• Mitjançant l'ús de MockSetting, podem afegir fàcilment altres configuracions simulades quan sigui necessari.
• Combina diferents configuracions simulades sense fer malbé el codi.

La signatura del mètode withSettings() és:

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