Mockito espion méthode ne fonctionne pas

Je suis en difficulté avec mockito.spy méthode.

Je suis récemment arrivé sur un "vieux" projet et ma première tâche est d'ajouter mockito, et de faire vrai test de l'unité 🙂

le projet a de nombreux problèmes de conception, mais n'est pas le point ici 😉

J'explique mon problème:

J'ai une classe

public class Tutu{
  public Tutu(){
  }
}

public class Toto{
  public Toto(){
  }
  public int executeToto(Tutu tutu){
    //do some stuff
    return 5;
  }
}

public class Titi{
  private Toto toto;

  public Titi(){
     this.toto = new Toto();     
  }

  public void executeTiti(){
      //do some stuff
      Tutu tutu = new Tutu();
      int ret = this.toto.executeToto(tutu);
      //do some stuff
  }
}

dans ma classe de test TitiTest.java je veux tester seulement executeTiti, je ne veux pas de test executeToto des trucs parce que cette classe a est propre classe de test TotoTest.java.

mais comme vous pouvez le voir, toto est instancier en titi constructeur donc j'ai essayer quelque chose comme cela:
(Je suis en utilisant PowerMock dans mon test trop, donc je suis en utilisant PowerMockRunner mais il ne semble pas être le problème)

@RunWith(PowerMockRunner.class)
public class TitiTest {

 @Test
 public void testExecuteTiti(){
   Toto toto = Mockito.spy(new Toto());
   Mockito.doReturn(2).when(toto).executeToto(Mockito.any(Tutu.class));

   Titi testedObject = new Titi();
   testedObject.executeTiti();
 }
}

mais la vraie méthode est toujours d'appel et ret = 5 à chaque fois 🙁

Dois-je raté quelque chose? J'ai lu beaucoup de post à ce sujet sur stackoverflow et d'essayer toutes les solution mais il n'a jamais travailler parce que je pense que je suis en train de faire la bonne chose.

- Je utiliser junit4.11/powermock1.5.4/mockito1.9.5

InformationsquelleAutor Mançaux Pierre-Alexandre | 2014-03-13

9
```
Toto toto = Mockito.spy(new Toto());
```
Garder à l'esprit que ce espions/stubs sur le Toto exemple vous créez dans cette ligne, et non pas chaque nouvellement créé Toto. Ainsi, lorsque vous composez le:
```
Titi testedObject = new Titi();
testedObject.executeTiti();
```
Le constructeur new Titi() lui-même crée une nouvelle instance de Toto, affectée par Mockito, de sorte que l'appel à this.toto.executeAction() retournera toujours 5.

Parce que vous êtes en cours d'exécution avec PowerMockito, vous avez la possibilité de stubbing de Toto constructeur:
```
@RunWith(PowerMockRunner.class)
@PrepareForTest(Titi.class) //stub the calling class Titi, not Toto!
public class TitiTest {
  @Test public void testExecuteTiti() {
    Toto toto = Mockito.spy(new Toto());
    Mockito.doReturn(2).when(toto).executeToto(Mockito.any(Tutu.class));

    PowerMockito.whenNew(Toto.class).withAnyArguments().thenReturn(toto);

    Titi testedObject = new Titi();
    testedObject.executeTiti();
  }
}
```
Mais l'option que j'aime le mieux est de créer un secondaire constructeur pour Titi, pour les essais de:
```
public Titi(){
  this.toto = new Toto();     
}

/** For testing only. Uses the passed Toto instance instead of a new one. */
Titi(Toto toto){
  this.toto = toto;
}
```
Qui ne nécessite que de vous adapter votre test comme ceci:
```
@Test public void testExecuteTiti(){
  Toto toto = Mockito.spy(new Toto());
  Mockito.doReturn(2).when(toto).executeToto(Mockito.any(Tutu.class));

  Titi testedObject = new Titi(toto);
  testedObject.executeTiti();
}
```
- bonjour, merci pour l'aide, après avoir poster ma question j'ai enfin changer le constructeur pour passer du bon exemple et de son travail. je veux juste savoir si il y a une autre solution parce que c'était l'héritage de code avec aucun test et je ne veux pas toucher au code existant, mais je suis d'accord avec vous, je n'ai pas le choix dans ce cas :)merci
- Je pense qu'un rapide refactorisation de code legacy est facilement la peine de faire des tests de mieux, mais vous pouvez poursuivre la PowerMockito solution dans la réponse, sans changer le code de production. Vous devrez peut-être ajuster la PowerMockito code si mon expérience est limitée. Bonne chance!
InformationsquelleAutor Jeff Bowman

Ce qui vous semble manquer, c'est le fait que votre Espion pour le compte de Toto classe n'est jamais réellement utilisé par le Titi classe.

Ce que je ferais dans ton cas est

1) Refactoriser le Titi classe d'accepter Toto comme une dépendance dans le constructeur. De cette façon, vous pouvez facilement créer Titi avec toute Toto (et il y en pour l'utilisation d'une maquette de votre unité de test)

2) Si l'option 1 est hors de question que vous pouvez faire ce qui suit:

public class Titi{
  private Toto toto;

  public Titi(){
     this.toto = new Toto();     
  }

  public void executeTiti(){
      //do some stuff
      Tutu tutu = new Tutu();
      int ret = getToto().executeToto(tutu);
      //do some stuff
  }

  //package private - used for overriding via spying 
  Toto getToto() {
      return toto;
  }
}

@RunWith(MockitoJUnitRunner.class)
public class TitiTest {

 @Test
 public void testExecuteTiti(){
   Toto toto = Mockito.mock(Toto.class);
   when(toto.executeToto(Mockito.any(Tutu.class)).thenReturn(2);

   Titi testedObject = new Titi();
   testedObject = spy(testedObject);
   doReturn(toto).when(testedObject).getToto();

   testedObject.executeTiti();
 }
}

oui, comme je l'ai dit sur la réponse précédente, je n'ai pas le choix de changer de constructeur. merci aussi pour votre aide 🙂

InformationsquelleAutor geoand

0

Voici un article qui décrit l'utilisation d'une ligne de méthodes ou à l'usine, méthodes d'aide pour tester des classes qui ne sont pas injecter des collaborateurs. https://code.google.com/p/mockito/wiki/MockingObjectCreation

InformationsquelleAutor chris topinka

Vous devez vous connecter pour publier un commentaire.