Excepción: Mockito buscado pero no invocado. En realidad, no hubo interacciones con este simulacro.

3 minutos de lectura

avatar de usuario de user3096719
usuario3096719

tengo interfaz

Interface MyInterface {
  myMethodToBeVerified (String, String);
}

Y la implementación de la interfaz es

class MyClassToBeTested implements MyInterface {
   myMethodToBeVerified(String, String) {
    …….
   }
}

tengo otra clase

class MyClass {
    MyInterface myObj = new MyClassToBeTested();
    public void abc(){
         myObj.myMethodToBeVerified (new String(“a”), new String(“b”));
    }
}

Estoy tratando de escribir JUnit para MyClass. he hecho

class MyClassTest {
    MyClass myClass = new MyClass();
  
    @Mock
    MyInterface myInterface;

    testAbc(){
         myClass.abc();
         verify(myInterface).myMethodToBeVerified(new String(“a”), new String(“b”));
    }
}

pero estoy recibiendo mockito buscado pero no invocado, en realidad no hubo interacciones con este simulacro al verificar la llamada.

alguien puede sugerir algunas soluciones.

Avatar de usuario de Jk1
Jk1

Debe inyectar simulacros dentro de la clase que está probando. En este momento estás interactuando con el objeto real, no con el simulado. Puede corregir el código de la siguiente manera:

void testAbc(){
     myClass.myObj = myInteface;
     myClass.abc();
     verify(myInterface).myMethodToBeVerified(new String("a"), new String("b"));
}

aunque sería una opción más sabia extraer todo el código de inicialización en @Before

@Before
void setUp(){
     myClass = new myClass();
     myClass.myObj = myInteface;
}

@Test
void testAbc(){
     myClass.abc();
     verify(myInterface).myMethodToBeVerified(new String("a"), new String("b"));
}

  • ¿Por qué no podemos usar Mockito.mock ¿aquí?

    – Igor Ganapolski

    23 de enero de 2017 a las 16:23

  • @IgorGanapolsky: Podemos usar Mockito.mock, para eso tenemos que usar un método setter para myObj y establecer el objeto simulado en myObj.

    – vijaya kumar

    22 de febrero de 2017 a las 21:27

Tu clase MyClass crea un nuevo MyClassToBeTesteden lugar de usar su simulacro. Mi artículo en la wiki de Mockito describe dos maneras de lidiar con esto.

  • HikariDataSourceProvider dataSourceProvider = mock(DataSourceProvider.class); verificar (proveedor de origen de datos). apagar (); cual es el problema

    – Irfan Nasim

    18 de julio de 2018 a las 9:43

Avatar de usuario de Kevin Welker
kevin welker

La respuesta de @ Jk1 está bien, pero Mockito también permite una inyección más sucinta usando anotaciones:

@InjectMocks MyClass myClass; //@InjectMocks automatically instantiates too
@Mock MyInterface myInterface

Pero independientemente del método que use, las anotaciones no se procesan (ni siquiera su @Mock) a menos que de alguna manera llame al static MockitoAnnotation.initMocks() o anotar la clase con @RunWith(MockitoJUnitRunner.class).

avatar de usuario de vijaya kumar
vijaya kumar

La respuesta de @jk1 es perfecta, ya que @igor Ganapolsky preguntó, ¿por qué no podemos usar Mockito.mock aquí? publico esta respuesta

Para eso, proporcionamos un método de establecimiento para myobj y establecemos el valor de myobj con el objeto simulado.

class MyClass {
    MyInterface myObj;

    public void abc() {
        myObj.myMethodToBeVerified (new String("a"), new String("b"));
    }

    public void setMyObj(MyInterface obj)
    {
        this.myObj=obj;
    }
}

En nuestra clase de prueba, tenemos que escribir el siguiente código

class MyClassTest {

MyClass myClass = new MyClass();

    @Mock
    MyInterface myInterface;

    @test
    testAbc() {
        myclass.setMyObj(myInterface); //it is good to have in @before method
        myClass.abc();
        verify(myInterface).myMethodToBeVerified(new String("a"), new String("b"));
     }
}

Esta excepción también se puede lanzar si, por ejemplo, espera que se ejecute thisMethod(), pero no fue así. No lo hizo porque está dentro de una condición que no se cumplió.

Por ejemplo, si tiene alguna prueba de unidad que dice que verifique que este Método () se ejecute, pero de hecho, no fue porque varX y varY no son iguales.

//method expected to be called.    
if( varX == varY){
     thisMethod();
  }

 //test
 Mockito.verify(foo).thisMethod();

¿Ha sido útil esta solución?