Busqué en Google esto, pero no encontré nada relevante. Tengo algo como esto:

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

Ahora, quiero verificar que mymethod(Object o), que se llama dentro runtestmethod(), se llamó con el Objeto o, no con ningún otro. Pero siempre paso la prueba, lo que sea que ponga en la verificación, por ejemplo, con:

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

o

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

o

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

Siempre paso la prueba. ¿Cómo puedo lograr esa verificación (si es posible)?

Gracias.

Una alternativa a ArgumentMatcheres ArgumentCaptor.

Ejemplo oficial:

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

Un captor también se puede definir utilizando la anotación @Captor :

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

¿Estás tratando de hacer la igualdad lógica utilizando el método .equals del objeto? Puede hacerlo utilizando el emparejador argThat que se incluye en Mockito

import static org.mockito.Matchers.argThat

A continuación, puede implementar su propio emparejador de argumentos que diferirá para cada método .equals de objetos

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

Ahora, usando su código, puede actualizarlo para leer ...

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

Si solo busca la igualdad EXACTA (mismo objeto en la memoria), simplemente haga

verify(mock).mymethod(obj);

Esto verificará que se haya llamado una vez.

• No necesita el eqmatcher si no utiliza otros matchers.
• No está utilizando la sintaxis correcta: su llamada al método debe estar fuera de .verify(mock). Ahora está iniciando la verificación del resultado de la llamada al método, sin verificar nada (sin hacer una llamada al método). Por lo tanto, todas las pruebas están pasando.

Su código debe verse así:

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

argThat más lambda

así es como puede fallar la verificación de su argumento:

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

dónde

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

argThat más afirma

la prueba anterior "dirá" Expected: lambda$... Was: YourClass.toSting.... Puede obtener una causa más específica de la falla si usa afirmaciones en la lambda:

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

PERO: ESTO SOLO FUNCIONA CON 1 LLAMADA DE MÉTODO. Si el método verificado se llama 2 o más veces, mockito pasa todas las combinaciones llamadas a cada verificador. Entonces, mockito espera que su verificador regrese silenciosamente truepara uno de los argumentos establecidos y false(sin excepciones de afirmación) para otras llamadas válidas. Esa expectativa no es un problema para 1 llamada al método, solo debe devolver 1 vez verdadero.

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

Ahora la prueba dice: Expected: Obj.description to contain 'KEY'. Was: 'Actual description'. NOTA: Utilicé assertJafirmaciones, pero depende de usted qué marco de afirmación usar.

argThat con múltiples argumentos

Si usa argThat, todos los argumentos deben ser provistos con coincidencias. P.ej:

    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.

dónde:

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

eq matcher

La forma más fácil de verificar si el argumento es igual:

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

argumento directo

Si la comparación por referencia es aceptable, continúe con:

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

La causa fundamental del fracaso pregunta original era el lugar equivocado de las paranthes: verify(mock.mymethod.... Eso estuvo mal. El derecho sería:verify(mock).*

He usado Mockito.verify de esta manera

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

¿Ha verificado el método de igualdad para la clase simulable? Si este devuelve siempre verdadero o prueba la misma instancia contra la misma instancia y el método de igualdad no se sobrescribe (y por lo tanto solo verifica las referencias), entonces devuelve verdadero.

El otro método es usar el método org.mockito.internal.matchers.Equals.Equals en lugar de redefinir uno:

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

¿Lo has probado con el mismo () matcher? Como en:

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

Yo tuve el mismo problema. Lo probé con el igualador eq () así como con el igualador refEq () pero siempre tuve falsos positivos. Cuando utilicé el mismo () matcher, la prueba falló cuando los argumentos eran instancias diferentes y pasaban una vez que los argumentos eran la misma instancia.

También puede usar 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());
        }
    };
}

Luego verifique esa invocación:

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