He buscado en Google sobre 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 comprobar que mymethod(Object o)que se llama dentro runtestmethod()fue llamado con el Objeto o, no cualquier otro. Pero siempre paso la prueba, ponga lo 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 ArgumentMatcher es 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 usando el @Apresador anotación:

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

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 CUANDO

• LA LLAMADA SE ESPERA 1 VEZ, o
• la llamada se espera más de 2 veces, pero todas las veces el verificador coincide (devuelve true).

Si el método verificado llamó más de 2 veces, mockito pasa todas las combinaciones llamadas a cada verificador. Asi que mockito espera que tu verificador regrese silenciosamente true para uno de los conjuntos de argumentosy false (sin afirmar excepciones) para otras llamadas válidas. Esa expectativa no es un problema para 1 llamada de método; solo debería devolver verdadero 1 vez.

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

Ahora la prueba fallida dirá: Expected: Obj.description to contain 'KEY'. Was: 'Actual description'. NOTA: he usado assertJ afirma, pero depende de usted qué marco de afirmación usar.

---

argumento directo

Mokito compara argumentos directos usando equals():

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

---

eq emparejador

• Nunca usar eq para un solo argumento. Usa lo antes mencionado argumento directo.
• Mokito compara argumentos directos usando equals()
• Razón: eq sería una violación de SonarQube / SonarClound: https://rules.sonarsource.com/java/tag/mockito/RSPEC-6068

---

argThat con múltiples argumentos.

Si utiliza argThat, todos los argumentos debe estar provisto de fósforos. Por ejemplo, si, en otro caso, tenías otro método con 2 argumentos:

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

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

// above is incorrect; an exception will be thrown, as the first 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;

---

LA CAUSA RAÍZ del fracaso de la pregunta original era el lugar equivocado de los paréntesis:

• verify(mock.mymethod.... Eso estuvo mal. El derecho sería:
• verify(mock).*

¿Está tratando de hacer una igualdad lógica utilizando el método .equals del objeto? Puede hacer esto utilizando el comparador argThat que se incluye en Mockito

import static org.mockito.Matchers.argThat

A continuación, puede implementar su propio comparador de argumentos que diferirá del método .equals de cada objeto

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 que lea…

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 (el mismo objeto en la memoria), simplemente haga

verify(mock).mymethod(obj);

Esto verificará que fue llamado una vez.

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

Su código debe verse como:

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

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

¿Has comprobado el método equals para la clase simulada? Si este devuelve siempre verdadero o prueba la misma instancia contra la misma instancia y el método igual 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)));