Mockito: ¿cómo verificar que el método fue llamado en un objeto creado dentro de un método?

La respuesta clásica es, "Usted no." Usted prueba la API pública de Foo, no sus internos.

¿Hay algún comportamiento del objeto Foo (o, menos bueno, algún otro objeto en el entorno) que se vea afectado por foo()? Si es así, prueba eso. Y si no, ¿qué hace el método?

Si no desea utilizar DI o Fábricas. Puedes refactorizar tu clase de una manera un poco complicada:

public class Foo {
    private Bar bar;

    public void foo(Bar bar){
        this.bar = (bar != null) ? bar : new Bar();
        bar.someMethod();
        this.bar = null;  // for simulating local scope
    }
}

Y su clase de prueba:

@RunWith(MockitoJUnitRunner.class)
public class FooTest {
    @Mock Bar barMock;
    Foo foo;

    @Test
    public void testFoo() {
       foo = new Foo();
       foo.foo(barMock);
       verify(barMock, times(1)).someMethod();
    }
}

Entonces la clase que está llamando a tu método foo lo hará así:

public class thirdClass {

   public void someOtherMethod() {
      Foo myFoo = new Foo();
      myFoo.foo(null);
   }
}

Como puede ver al llamar al método de esta manera, no necesita importar la clase Bar en ninguna otra clase que esté llamando a su método foo, que tal vez sea algo que desee.

Por supuesto, la desventaja es que está permitiendo que la persona que llama establezca el Objeto Bar.

Espero que ayude.

Solución para su código de ejemplo usando PowerMockito.whenNew

• mockito-todos 1.10.8
• powermock-core 1.6.1
• powermock-module-junit4 1.6.1
• powermock-api-mockito 1.6.1
• junit 4.12

FooTest.java

package foo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

//Both @PrepareForTest and @RunWith are needed for `whenNew` to work 
@RunWith(PowerMockRunner.class)
@PrepareForTest({ Foo.class })
public class FooTest {

    // Class Under Test
    Foo cut;

    @Mock
    Bar barMock;

    @Before
    public void setUp() throws Exception {
        cut = new Foo();

    }

    @After
    public void tearDown() {
        cut = null;

    }

    @Test
    public void testFoo() throws Exception {

        // Setup
        PowerMockito.whenNew(Bar.class).withNoArguments()
                .thenReturn(this.barMock);

        // Test
        cut.foo();

        // Validations
        Mockito.verify(this.barMock, Mockito.times(1)).someMethod();

    }

}

JUnit Output

Creo que Mockito @InjectMocks es el camino a seguir.

Dependiendo de tu intención puedes usar:

1. Inyección de constructor
2. Inyección de setter de propiedades
3. Inyección de campo

Más información en docs

A continuación se muestra un ejemplo con la inyección de campo:

Clases:

public class Foo
{
    private Bar bar = new Bar();

    public void foo() 
    {
        bar.someMethod();
    }
}

public class Bar
{
    public void someMethod()
    {
         //something
    }
}

Prueba:

@RunWith(MockitoJUnitRunner.class)
public class FooTest
{
    @Mock
    Bar bar;

    @InjectMocks
    Foo foo;

    @Test
    public void FooTest()
    {
        doNothing().when( bar ).someMethod();
        foo.foo();
        verify(bar, times(1)).someMethod();
    }
}

Sí, si realmente quieres / necesitas hacerlo puedes usar PowerMock. Esto debe considerarse un último recurso. Con PowerMock puede hacer que devuelva un simulacro de la llamada al constructor. Luego haz la verificación en el simulacro. Dicho esto, csturtz es la respuesta "correcta".

Aquí está el enlace a Construcción simulada de nuevos objetos

Otra forma sencilla sería añadir alguna instrucción log a la barra.someMethod() y luego asegúrese de que puede ver dicho mensaje cuando se ejecuta su prueba, vea ejemplos aquí: Cómo hacer una afirmación JUnit en un mensaje en un registrador

Eso es especialmente útil cuando su barra.someMethod() es private.