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

Question

Je suis nouveau sur Mockito.

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

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

Je voudrais faire l'appel de vérification suivant,

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

où bar est une instance simulée de Bar .

Answer 1

Injection de dépendances

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 le faire), 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 : Il s'agit d'un exemple de la manière dont la méthode TDD peut influencer la conception de votre code.

Answer 2

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

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

Answer 3

Si vous ne voulez pas utiliser DI ou Factories. Vous pouvez remanier votre classe d'une manière un peu plus 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();
    }
}

Alors 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 constater, en appelant la méthode de cette manière, 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 ce que vous voulez.

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

J'espère que cela vous aidera.

Answer 4

Vérifiez http://code.google.com/p/mockito/wiki/MockingObjectCreation?ts=1332544670&updated=MockingObjectCreation qui donne deux façons de contourner ce problème, sans l'utilisation de PowerMock.

Answer 5

Oui, si vous voulez vraiment / devez le faire, vous pouvez utiliser PowerMock. Cela doit être considéré comme un dernier recours. Avec PowerMock, vous pouvez faire en sorte qu'il renvoie un objet fantaisie à partir de l'appel au constructeur. Ensuite, faites la vérification sur le mock. Cela dit, la réponse de Csturtz est la "bonne" réponse.

Voici le lien vers Construction fictive de nouveaux objets