Przykład na argumentie MockitoCaptor

Question

Czy ktoś może podać mi przykład pokazujący, jakie jest użycie klasy org.mockito.ArgumentCaptor i jak to jest inne niż proste matchers, które są dostarczane z mockito.

Czytam dostarczone dokumenty mockito, ale te nie ilustrują tego jasno, ani nie są w stanie wyjaśnić tego z całą pewnością.

Answer 1

Dwie główne różnice to:

• podczas wykonywania ani jednego argumentu, jesteś w stanie zrobić o wiele bardziej skomplikowane testy na tym argumencie, a także z bardziej oczywistych kodu;
• an ArgumentCaptor może przechwycić więcej niż jeden.

Aby zilustrować ten ostatni, że masz:

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

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

Następnie porywacz będzie w stanie dać Ci dostęp do wszystkich 4 argumentów, które można następnie wykonać twierdzeń oddzielnie.

Ta lub dowolna liczba argumentów w rzeczywistości, ponieważ VerificationMode nie jest ograniczona do ustalonej liczby wywołań; w każdym razie, porywacz da ci dostęp do nich wszystkich, jeśli chcesz.

Ma to również tę zaletę, że takie testy są (imho) o wiele łatwiejsze do napisania niż konieczność implementacji własnych ArgumentMatcher s - szczególnie jeśli łączysz mockito z assertj.

Aha, i proszę rozważyć użycie TestNG zamiast JUnit.

Answer 2

Zgadzam się z tym, co powiedział @fge, więcej. Spójrzmy na przykład. Rozważyć masz metodę:

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

Teraz, jeśli chcesz, aby sprawdzić dane wewnętrzną można użyć captor:

// 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

pod uwagę scenariusz, w którym testujemy metodę, która zależy od współpracownika . Ten współpracownik bierze argument podczas wywoływania jednej ze swoich metod. Teraz nie może być dwóch scenarios- 1. Argument jest przekazywana na zewnątrz metodą testujemy, a następnie wykorzystywane przez współpracownika podczas własnej wywołania metody

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

Aby przetestować tę metodę możemy mock kolaboranta a następnie wywołać metodę następująco

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

Więc tutaj w metodzie testowej mamy arg1 instancji, a zatem mogą być weryfikowane
2.Argument używany przez współpracownika, aby jego własna wywołanie metody nie są przekazywane na zewnątrz i jednak tworzone wewnątrz metody testowane

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

Aby przetestować tę metodę możemy mock współpracownika, a następnie wywołać metodę następująco

method();

Ale w jaki sposób możemy sprawdzić, z jakim współpracownikiem wywołano argumenty, ponieważ nie mamy dostępu do argumentu, ponieważ został on utworzony wewnętrznie wewnątrz metody. To tam pojawia się obraz Mockito ArgumentCaptor.
Używając ArgumentCaptor możemy uzyskać instancję argumentu utworzoną wewnętrznie i wykorzystaną w wywołaniu współpracownika, dzięki czemu możemy ją zweryfikować.

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

Reference- Understanding Mockito ArgumentCaptor using Spring Boot Test Example