Mockito: como verificar se o método foi chamado em um objeto criado dentro de um método?

Eu sou novo em Mockito.

Dada a classe abaixo, como posso usar o Mockito para verificar se someMethodfoi chamado exatamente uma vez depois de ter foosido chamado?

public class Foo
{
    public void foo(){
        Bar bar = new Bar();
        bar.someMethod();
    }
}

Gostaria de fazer a seguinte chamada de verificação,

verify(bar, times(1)).someMethod();

Onde baré uma instância zombada de Bar.

Injeção de dependência

Se você injetar a instância Bar, ou uma fábrica usada para criar a instância Bar (ou uma das outras 483 maneiras de fazer isso), você terá o acesso necessário para realizar o teste.

Exemplo de fábrica:

Dada uma classe Foo escrita assim:

public class Foo {
  private BarFactory barFactory;

  public Foo(BarFactory factory) {
    this.barFactory = factory;
  }

  public void foo() {
    Bar bar = this.barFactory.createBar();
    bar.someMethod();
  }
}

no seu método de teste, você pode injetar um BarFactory como este:

@Test
public void testDoFoo() {
  Bar bar = mock(Bar.class);
  BarFactory myFactory = new BarFactory() {
    public Bar createBar() { return bar;}
  };

  Foo foo = new Foo(myFactory);
  foo.foo();

  verify(bar, times(1)).someMethod();
}

Bônus: Este é um exemplo de como o TDD pode orientar o design do seu código.

A resposta clássica é: "Você não". Você testa a API pública de Foo, não suas internas.

Existe algum comportamento do Fooobjeto (ou menos bom, algum outro objeto no ambiente) que é afetado foo()? Se sim, teste isso. E se não, o que o método faz?

Se você não quiser usar DI ou Fábricas. Você pode refatorar sua classe de uma maneira um pouco 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
    }
}

E sua classe de teste:

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

Em seguida, a classe que está chamando seu método foo fará o seguinte:

public class thirdClass {

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

Como você pode ver ao chamar o método dessa maneira, não é necessário importar a classe Bar em nenhuma outra classe que esteja chamando seu método foo, que talvez seja algo que você deseja.

Obviamente, a desvantagem é que você está permitindo que o chamador defina o Objeto de barra.

Espero que ajude.

Solução para o seu código de exemplo usando PowerMockito.whenNew

• mockito-all 1.10.8
• powermock-core 1.6.1
• powermock-module-junit4 1.6.1
• powermock-api-mockito 1.6.1
• junho 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();

    }

}

Saída JUnit

Eu acho que Mockito @InjectMocksé o caminho a percorrer.

Dependendo da sua intenção, você pode usar:

1. Injeção de construtor
2. Injeção de setter de propriedade
3. Injeção em campo

Mais informações nos documentos

Abaixo está um exemplo com injeção de campo:

Aulas:

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

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

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

Teste:

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

Sim, se você realmente deseja / precisa fazer isso, pode usar o PowerMock. Isso deve ser considerado um último recurso. Com o PowerMock, você pode fazer com que ele retorne uma simulação da chamada ao construtor. Em seguida, verifique a simulação. Dito isto, csturtz's é a resposta "certa".

Aqui está o link para a construção simulada de novos objetos

Outra maneira simples seria adicionar alguma instrução de log ao bar.someMethod () e verificar se você pode ver a mensagem mencionada quando o teste foi executado, veja exemplos aqui: Como fazer uma JUnit afirmar uma mensagem em um logger

Isso é especialmente útil quando o seu Bar.someMethod () é private.