Mockito: comment vérifier que la méthode a été appelée sur un objet créé dans une méthode?

Je suis nouveau chez Mockito.

Étant donné la classe ci-dessous, comment puis-je utiliser Mockito pour vérifier qu'il a someMethodété invoqué exactement une fois après avoir fooété invoqué?

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

Je souhaite effectuer l'appel de vérification suivant,

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

où barest une instance moquée de Bar.

Injection de dépendance

Si vous injectez l'instance Bar, ou une fabrique utilisée pour créer l'instance Bar (ou l'une des 483 autres façons de procéder), vous aurez l'accès nécessaire pour effectuer le test.

Exemple d'usine:

Étant donné une classe Foo écrite comme ceci:

public class Foo {
  private BarFactory barFactory;

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

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

dans votre méthode de test, vous pouvez injecter une BarFactory comme ceci:

@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: Ceci est un exemple de la façon dont TDD peut piloter la conception de votre code.

La réponse classique est: "Vous ne le faites pas." Vous testez l'API publique de Foo, pas ses internes.

Y a-t-il un comportement de l' Fooobjet (ou, moins bien, un autre objet dans l'environnement) qui est affecté par foo()? Si oui, testez cela. Et sinon, que fait la méthode?

Si vous ne souhaitez pas utiliser DI ou les usines. Vous pouvez remanier votre classe d'une manière un peu délicate:

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

Et votre classe de 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();
    }
}

Ensuite, la classe qui appelle votre méthode foo le fera comme ceci:

public class thirdClass {

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

Comme vous pouvez le voir lorsque vous appelez la méthode de cette façon, vous n'avez pas besoin d'importer la classe Bar dans une autre classe qui appelle votre méthode foo, ce qui est peut-être quelque chose que vous voulez.

Bien sûr, l'inconvénient est que vous autorisez l'appelant à définir l'objet Bar.

J'espère que ça aide.

Solution pour votre exemple de code en utilisant PowerMockito.whenNew

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

    }

}

Sortie JUnit

Je pense que Mockito @InjectMocksest la voie à suivre.

Selon votre intention, vous pouvez utiliser:

1. Injection constructeur
2. Injection de définition de propriété
3. Injection sur le terrain

Plus d'informations dans les documents

Voici un exemple avec injection de champ:

Des classes:

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

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

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

Tester:

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

Oui, si vous voulez / devez vraiment le faire, vous pouvez utiliser PowerMock. Cela devrait être considéré comme un dernier recours. Avec PowerMock, vous pouvez lui faire renvoyer une maquette de l'appel au constructeur. Faites ensuite la vérification sur la maquette. Cela dit, csturtz est la «bonne» réponse.

Voici le lien vers Mock construction de nouveaux objets

Une autre façon simple serait d'ajouter une instruction log à bar.someMethod () puis de vérifier que vous pouvez voir ledit message lorsque votre test est exécuté, voir des exemples ici: Comment faire une assertion JUnit sur un message dans un enregistreur

C'est particulièrement pratique lorsque votre Bar.someMethod () l'est private.