Googlowałem na ten temat, ale nie znalazłem nic istotnego. Mam coś takiego:

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();

Teraz chcę sprawdzić, czy to mymethod(Object o), co nazywa się wewnątrz runtestmethod(), zostało wywołane z Obiektem o, a nie z żadnym innym. Ale zawsze zdaję test, niezależnie od tego, co poddam weryfikacji, na przykład:

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

lub

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

lub

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

Zawsze zdaję test. Jak mogę przeprowadzić tę weryfikację (jeśli to możliwe)?

Dziękuję Ci.

Alternatywą dla ArgumentMatcherjest ArgumentCaptor.

Oficjalny przykład:

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

Captor można również zdefiniować za pomocą adnotacji @Captor :

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

Czy próbujesz osiągnąć logiczną równość, korzystając z metody .equals obiektu? Możesz to zrobić, korzystając z argumentu argThat, który jest zawarty w Mockito

import static org.mockito.Matchers.argThat

Następnie możesz zaimplementować własny moduł dopasowywania argumentów, który będzie odraczał metodę .equals każdego obiektu

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);
    }
}

Teraz za pomocą kodu możesz go zaktualizować, aby czytać ...

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)));

Jeśli chcesz uzyskać DOKŁADNĄ równość (ten sam obiekt w pamięci), po prostu zrób

verify(mock).mymethod(obj);

Spowoduje to sprawdzenie, że raz został wywołany.

• Nie potrzebujesz eqdopasowywania, jeśli nie używasz innych dopasowań.
• Nie używasz poprawnej składni - twoje wywołanie metody powinno znajdować się poza .verify(mock). Teraz inicjujesz weryfikację wyniku wywołania metody, nie weryfikując niczego (nie wykonując wywołania metody). Dlatego wszystkie testy przebiegają pomyślnie.

Twój kod powinien wyglądać następująco:

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

argThat plus lambda

w ten sposób możesz zawieść weryfikację argumentów:

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

gdzie

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

argThat plus zapewnia

powyższy test „powie” Expected: lambda$... Was: YourClass.toSting.... Możesz uzyskać dokładniejszą przyczynę niepowodzenia, jeśli używasz twierdzeń w lambda:

    verify(mock).mymethod(argThat( x -> {
      assertThat(x).isNotNull();
      assertThat(x.description).contains("KEY");
      return true;
    }));

ALE: TO TYLKO DZIAŁA Z 1 METODĄ WEZWANIA. Jeśli zweryfikowana metoda wywoływana jest 2 razy, mockito przekazuje wszystkie wywoływane kombinacje każdemu weryfikatorowi. Zatem mockito oczekuje, że weryfikator po cichu zwraca truejeden zestaw argumentów i false(bez wyjątków) dla innych prawidłowych wywołań. Oczekiwanie to nie stanowi problemu dla 1 wywołania metody - powinno po prostu zwrócić true 1 raz.

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.verify;

Teraz test mówi: Expected: Obj.description to contain 'KEY'. Was: 'Actual description'. UWAGA: Użyłem assertJasercji, ale to od Ciebie zależy, która struktura asercji będzie używana.

argThat z wieloma argumentami.

Jeśli używasz argThat, wszystkie argumenty muszą być dopasowane. Na przykład:

    verify(mock).mymethod(eq("VALUE_1"), argThat((x)->false));
    // above is correct as eq() is also an argument matcher.

verify(mock).mymethod("VALUE_1", argThat((x)->false));

// above is incorrect; an exceptoin will be thrown, as the fist arg. is given without an argument matcher.

gdzie:

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

eq dopasowujący

najprostszym sposobem sprawdzenia, czy argument jest równy:

verify(mock).mymethod(eq(expectedValue));
// NOTE:   ^ where the parentheses must be closed.

bezpośredni argument

jeśli porównanie przez odniesienie jest dopuszczalne, przejdź do:

verify(mock).mymethod(expectedArg);
// NOTE:   ^ where the parentheses must be closed.

Przyczyną awarii oryginalnego pytanie było złe miejsce z paranthes: verify(mock.mymethod.... To było złe. Prawo byłoby:verify(mock).*

Użyłem Mockito.verify w ten sposób

@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
    }
}

Czy sprawdziłeś metodę equals dla możliwej do wyśmiewania klasy? Jeśli ta zwraca zawsze true lub testujesz tę samą instancję na tej samej instancji, a metoda równości nie jest nadpisywana (a zatem sprawdza tylko referencje), wówczas zwraca true.

Inną metodą jest użycie metody org.mockito.internal.matchers.Equals.Equals zamiast ponownego zdefiniowania jednej:

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

Czy próbowałeś tego z tym samym () dopasowaniem? Jak w:

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

Miałem ten sam problem. Próbowałem z matcherem eq (), a także matcherem refEq (), ale zawsze miałem fałszywie dodatnie wyniki. Gdy użyłem tego samego () modułu dopasowującego, test nie powiódł się, gdy argumenty były różnymi instancjami i przeszedł, gdy argumenty były tej samej instancji.

Możesz także użyć TypeSafeDiagnosingMatcher

    private Matcher<GetPackagesRequest> expectedPackageRequest(final AvailabilityRequest request) {
    return new TypeSafeDiagnosingMatcher<GetPackagesRequest>() {

        StringBuilder text = new StringBuilder(500);

        @Override
        protected boolean matchesSafely(GetPackagesRequest req, Description desc) {
            String productCode = req.getPackageIds().iterator().next().getValue();
            if (productCode.equals(request.getSupplierProductCode())) {
                text.append("ProductCode not equal! " + productCode + " , " + request.getSupplierProductCode());
                return true;
            }

            text.append(req.toString());
            return false;
        }

        @Override
        public void describeTo(Description d) {
            d.appendText(text.toString());
        }
    };
}

Następnie sprawdź to wywołanie:

Mockito.verify(client).getPackages(Mockito.argThat(expectedPackageRequest(request)));