Mockito: come verificare il metodo è stato chiamato su un oggetto creato all'interno di un metodo?

Sono nuovo di Mockito.

Data la classe seguente, come posso usare Mockito per verificare che sia someMethodstato invocato esattamente una volta dopo che è foostato invocato?

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

Vorrei effettuare la seguente chiamata di verifica,

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

dove barè un'istanza derisa di Bar.

Iniezione di dipendenza

Se si inietta l'istanza Bar o una factory utilizzata per creare l'istanza Bar (o uno degli altri 483 modi per farlo), si avrebbe l'accesso necessario per eseguire il test.

Esempio di fabbrica:

Data una lezione Foo scritta in questo modo:

public class Foo {
  private BarFactory barFactory;

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

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

nel tuo metodo di test puoi iniettare una BarFactory in questo modo:

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

Bonus: questo è un esempio di come TDD può guidare la progettazione del tuo codice.

La risposta classica è "Non lo fai". Si verifica l'API pubblica di Foo, non i suoi interni.

C'è qualche comportamento Foodell'oggetto (o, meno buono, qualche altro oggetto nell'ambiente) che è interessato foo()? In tal caso, provalo. E se no, cosa fa il metodo?

Se non si desidera utilizzare DI o Factory. Puoi riformattare la tua classe in un modo un po 'complicato:

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 la tua classe di test:

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

Quindi la classe che chiama il tuo metodo foo lo farà in questo modo:

public class thirdClass {

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

Come puoi vedere quando chiami il metodo in questo modo, non è necessario importare la classe Bar in qualsiasi altra classe che chiama il tuo metodo foo che è forse qualcosa che desideri.

Naturalmente il rovescio della medaglia è che si sta permettendo al chiamante di impostare l'oggetto barra.

Spero che sia d'aiuto.

Soluzione per il tuo codice di esempio utilizzando PowerMockito.whenNew

• mockito-all 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();

    }

}

Uscita JUnit

Penso che Mockito @InjectMockssia la strada da percorrere.

A seconda delle tue intenzioni puoi usare:

1. Iniezione del costruttore
2. Iniezione setter proprietà
3. Iniezione di campo

Maggiori informazioni nei documenti

Di seguito è riportato un esempio con l'iniezione sul campo:

Classi:

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

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

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

Test:

@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ì, se vuoi davvero / hai bisogno di farlo, puoi usare PowerMock. Questo dovrebbe essere considerato l'ultima risorsa. Con PowerMock puoi far sì che restituisca una simulazione dalla chiamata al costruttore. Quindi esegui la verifica sul modello. Detto questo, Csturtz è la risposta "giusta".

Ecco il link alla costruzione simulata di nuovi oggetti

Un altro modo semplice sarebbe aggiungere alcune istruzioni di registro a bar.someMethod () e quindi accertarsi che sia possibile visualizzare il messaggio detto quando viene eseguito il test, vedere esempi qui: Come fare un'asserzione JUnit su un messaggio in un logger

Ciò è particolarmente utile quando Bar.someMethod () lo è private.