Esempio sull'argomento di MockitoCaptor

Question

Qualcuno può fornirci un esempio che mostri l'uso della classe e come sia diversa dagli abbinatori semplici forniti con mockito.

Ho letto i documenti mockito forniti ma quelli non lo illustrano chiaramente, né sono in grado di spiegarlo con chiarezza.

Answer 1

Le due differenze principali sono:

• quando si acquisisce anche un solo argomento, si è in grado di fare test molto più elaborato su questo argomento, e con il codice più evidente;
• un ArgumentCaptor può acquisire più di una volta.

Per illustrare questi ultimi, supponiamo di avere:

final ArgumentCaptor<Foo> captor = ArgumentCaptor.forClass(Foo.class); 

verify(x, times(4)).someMethod(captor.capture()); // for instance 

Poi il rapitore sarà in grado di dare accesso a tutti e 4 gli argomenti, che è quindi possibile eseguire affermazioni separatamente.

Questo o qualsiasi numero di argomenti in effetti, poiché uno VerificationMode non è limitato a un numero fisso di chiamate; in ogni caso, il rapitore ti darà accesso a tutti loro, se lo desideri.

Questo ha anche il vantaggio che tali test sono (imho) molto più facili da scrivere rispetto a dover implementare il proprio ArgumentMatcher s - in particolare se si combina mockito con assertj.

Oh, e si prega di prendere in considerazione l'utilizzo di TestNG invece di JUnit.

Answer 2

Sono d'accordo con ciò che ha detto @fge, più oltre. Diamo un'occhiata all'esempio. consideri di avere un metodo:

class A { 
    public void foo(OtherClass other) { 
     SomeData data = new SomeData("Some inner data"); 
     other.doSomething(data); 
    } 
} 

Ora, se si desidera controllare i dati interna è possibile utilizzare il rapitore:

// Create a mock of the OtherClass 
OtherClass other = mock(OtherClass.class); 

// Run the foo method with the mock 
new A().foo(other); 

// Capture the argument of the doSomething function 
ArgumentCaptor<SomeData> captor = ArgumentCaptor.forClass(SomeData.class); 
verify(other, times(1)).doSomething(captor.capture()); 

// Assert the argument 
SomeData actual = captor.getValue(); 
assertEquals("Some inner data", actual.innerData); 

Answer 3

consideri uno scenario in cui stiamo testando un metodo che dipende da un collaboratore . Questo collaboratore prende una discussione mentre chiama uno dei suoi metodi. Ora ci possono essere due scenarios- 1. L'argomento viene passato esternamente al metodo stiamo testando e poi utilizzato dal collaboratore durante il proprio metodo di chiamata

method(argument arg) 
    { 
    collaborator.callMethod(arg); 
    } 

Per testare questo metodo deridiamo collaboratore e quindi chiamare il metodo come segue

method(arg1); 
    Mockito.verify(collaborator).callMethod(arg1); 

Così qui nel metodo di prova abbiamo l'istanza arg1 e quindi può essere verificata
2.L'argomento utilizzato dal collaboratore per rendere il proprio metodo di chiamata non è passato esternamente ma crea all'interno del metodo in prova

method() 
{ 
arg=CreateArgumentInternally(); 
collaborator.callMethod(arg); 
} 

Per testare questo metodo deridiamo il collaboratore e quindi chiamare il metodo come segue

metodo

();

Ma come verificare che il collaboratore è stato chiamato con quali argomenti poiché non abbiamo l'accesso all'argomento poiché è stato creato internamente all'interno del metodo. Questo in cui il Mockito ArgumentCaptor entra in scena.
Usando ArgumentCaptor possiamo ottenere l'istanza argomento creata internamente e utilizzata nella chiamata collaboratore e quindi possiamo verificarla.

Mockito.verify(collaborator).callMethod(captor.capture()); 
    Argument actual = captor.getValue(); 

Reference Understanding Mockito ArgumentCaptor using Spring Boot Test Example