it-swarm.com.de

Mockito. Überprüfen Sie die Methodenargumente

Ich habe darüber gegoogelt, aber nichts Relevantes gefunden. Ich habe so etwas:

Object obj = getObject();
Mockeable mock= Mockito.mock(Mockeable.class);
Mockito.when(mock.mymethod(obj )).thenReturn(null);

Testeable testableObj = new Testeable();
testableObj.setMockeable(mock);
command.runtestmethod();

Nun möchte ich sicherstellen, dass mymethod(Object o), das in runtestmethod() aufgerufen wird, mit dem Object o aufgerufen wurde, nicht mit einem anderen. Aber ich habe den Test immer bestanden, egal, was ich für die Verifizierung angegeben habe, zum Beispiel mit:

Mockito.verify(mock.mymethod(Mockito.eq(obj)));

oder

Mockito.verify(mock.mymethod(Mockito.eq(null)));

oder

Mockito.verify(mock.mymethod(Mockito.eq("something_else")));

Ich bestehe immer die Prüfung. Wie kann ich diese Überprüfung durchführen (wenn möglich)?

Danke.

180
manolowar

Eine Alternative zu ArgumentMatcher ist ArgumentCaptor .

Offizielles Beispiel:

ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
verify(mock).doSomething(argument.capture());
assertEquals("John", argument.getValue().getName());

Ein Captor kann auch mit der Annotation @ Captor definiert werden:

@Captor ArgumentCaptor<Person> captor;
//... MockitoAnnotations.initMocks(this);
@Test public void test() {
    //...
    verify(mock).doSomething(captor.capture());
    assertEquals("John", captor.getValue().getName());
}
268
eugene82

Versuchen Sie, logische Gleichheit mithilfe der .equals-Methode des Objekts zu erzielen? Verwenden Sie dazu den in Mockito enthaltenen argThat-Matcher

import static org.mockito.Matchers.argThat

Als Nächstes können Sie einen eigenen Argumentvergleich implementieren, der sich auf die .equals-Methode jedes Objekts bezieht

private class ObjectEqualityArgumentMatcher<T> extends ArgumentMatcher<T> {
    T thisObject;

    public ObjectEqualityArgumentMatcher(T thisObject) {
        this.thisObject = thisObject;
    }

    @Override
    public boolean matches(Object argument) {
        return thisObject.equals(argument);
    }
}

Mit Ihrem Code können Sie ihn jetzt aktualisieren und lesen ...

Object obj = getObject();
Mockeable mock= Mockito.mock(Mockeable.class);
Mockito.when(mock.mymethod(obj)).thenReturn(null);

Testeable obj = new Testeable();
obj.setMockeable(mock);
command.runtestmethod();

verify(mock).mymethod(argThat(new ObjectEqualityArgumentMatcher<Object>(obj)));

Wenn Sie nur EXAKTE Gleichheit anstreben (dasselbe Objekt im Speicher), tun Sie dies einfach

verify(mock).mymethod(obj);

Dies wird überprüfen, ob es einmal aufgerufen wurde.

58
Matthew Kirkley
  • Sie benötigen den eq -Matcher nicht, wenn Sie keine anderen Matcher verwenden.
  • Sie verwenden nicht die richtige Syntax - Ihr Methodenaufruf sollte sich außerhalb von .verify(mock) befinden. Sie starten jetzt die Überprüfung des Ergebnisses des Methodenaufrufs, ohne etwas zu überprüfen (ohne einen Methodenaufruf durchzuführen). Damit sind alle Prüfungen bestanden.

Ihr Code sollte so aussehen:

Mockito.verify(mock).mymethod(obj);
Mockito.verify(mock).mymethod(null);
Mockito.verify(mock).mymethod("something_else");
47
Bozho

Ich habe Mockito.verify auf diese Weise verwendet

@UnitTest
public class JUnitServiceTest
{
    @Mock
    private MyCustomService myCustomService;


    @Test
    public void testVerifyMethod()
    {
       Mockito.verify(myCustomService, Mockito.never()).mymethod(parameters); // method will never call (an alternative can be pick to use times(0))
       Mockito.verify(myCustomService, Mockito.times(2)).mymethod(parameters); // method will call for 2 times
       Mockito.verify(myCustomService, Mockito.atLeastOnce()).mymethod(parameters); // method will call atleast 1 time
       Mockito.verify(myCustomService, Mockito.atLeast(2)).mymethod(parameters); // method will call atleast 2 times
       Mockito.verify(myCustomService, Mockito.atMost(3)).mymethod(parameters); // method will call at most 3 times
       Mockito.verify(myCustomService, Mockito.only()).mymethod(parameters); //   no other method called except this
    }
}
6
Free-Minded

Die andere Methode besteht darin, die Methode org.mockito.internal.matchers.Equals.Equals zu verwenden, anstatt eine neue zu definieren:

verify(myMock).myMethod((inputObject)Mockito.argThat(new Equals(inputObjectWanted)));
4
Nils Renaud

Haben Sie die Equals-Methode für die spottbare Klasse überprüft? Wenn dieser immer true zurückgibt oder Sie dieselbe Instanz mit derselben Instanz testen und die Methode equal nicht überschrieben wird (und daher nur die Referenzen überprüft), wird true zurückgegeben.

4
rit

so können Sie Ihre Argumente nicht verifizieren:

import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.verify;

    ...
    verify(mock).mymethod(argThat(
                                  (x)->false
                                 ));
2
epox

Haben Sie es mit demselben () Matcher versucht? Wie in:

verify(mockObj).someMethod(same(specificInstance));

Ich hatte das gleiche problem Ich habe es sowohl mit dem Matcher eq () als auch mit dem Matcher refEq () versucht, aber ich hatte immer falsch positive Ergebnisse. Wenn ich den gleichen () Matcher verwendete, schlug der Test fehl, wenn die Argumente unterschiedliche Instanzen waren und bestanden wurden, sobald die Argumente dieselbe Instanz waren.

1
cbbcloud