Mockito: Wie kann überprüft werden, ob eine Methode für ein in einer Methode erstelltes Objekt aufgerufen wurde?

Ich bin neu in Mockito.

Wie kann ich in der folgenden Klasse mit Mockito überprüfen, ob someMethodgenau einmal aufgerufen wurde, nachdem fooes aufgerufen wurde?

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

Ich möchte den folgenden Bestätigungsaufruf tätigen:

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

Wo barist eine verspottete Instanz von Bar.

Abhängigkeitsspritze

Wenn Sie die Bar-Instanz oder eine Factory einfügen, die zum Erstellen der Bar-Instanz verwendet wird (oder eine der anderen 483 Möglichkeiten, dies zu tun), haben Sie den erforderlichen Zugriff, um den Test durchzuführen.

Fabrikbeispiel:

Bei einer so geschriebenen Foo-Klasse:

public class Foo {
  private BarFactory barFactory;

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

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

In Ihrer Testmethode können Sie eine BarFactory wie folgt injizieren:

@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: Dies ist ein Beispiel dafür, wie TDD das Design Ihres Codes steuern kann.

Die klassische Antwort lautet: "Das tust du nicht." Sie testen die öffentliche API von Foo, nicht deren Interna.

Gibt es ein Verhalten des FooObjekts (oder, weniger gut, eines anderen Objekts in der Umgebung), das davon betroffen ist foo()? Wenn ja, testen Sie das. Und wenn nicht, was macht die Methode?

Wenn Sie DI oder Fabriken nicht verwenden möchten. Sie können Ihre Klasse auf etwas knifflige Weise umgestalten:

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

Und deine Testklasse:

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

Dann macht die Klasse, die Ihre foo-Methode aufruft, Folgendes:

public class thirdClass {

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

Wie Sie sehen können, wenn Sie die Methode auf diese Weise aufrufen, müssen Sie die Bar-Klasse nicht in eine andere Klasse importieren, die Ihre foo-Methode aufruft, was möglicherweise etwas ist, das Sie möchten.

Der Nachteil ist natürlich, dass Sie dem Anrufer erlauben, das Balkenobjekt festzulegen.

Ich hoffe es hilft.

Lösung für Ihren Beispielcode mit 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();

    }

}

JUnit-Ausgabe

Ich denke Mockito @InjectMocks ist der Weg.

Abhängig von Ihrer Absicht können Sie Folgendes verwenden:

1. Konstruktorinjektion
2. Property Setter Injection
3. Feldinjektion

Weitere Infos in den Dokumenten

Unten ist ein Beispiel mit Feldinjektion:

Klassen:

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

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

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

Prüfung:

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

Ja, wenn Sie es wirklich wollen / müssen, können Sie PowerMock verwenden. Dies sollte als letzter Ausweg betrachtet werden. Mit PowerMock können Sie veranlassen, dass ein Aufruf vom Aufruf an den Konstruktor zurückgegeben wird. Führen Sie dann die Überprüfung auf dem Mock durch. Das heißt, csturtz ist die "richtige" Antwort.

Hier ist der Link zur Scheinkonstruktion neuer Objekte

Eine andere einfache Möglichkeit wäre, der bar.someMethod () eine Protokollanweisung hinzuzufügen und dann sicherzustellen, dass Sie die besagte Nachricht sehen können, wenn Ihr Test ausgeführt wird. Siehe Beispiele hier: So führen Sie eine JUnit-Bestätigung für eine Nachricht in einem Logger durch

Das ist besonders praktisch, wenn Ihre Bar.someMethod () ist private.