Se moquer d'un constructeur avec paramètre

J'ai une classe comme ci-dessous:

public class A {
    public A(String test) {
        bla bla bla
    }

    public String check() {
        bla bla bla
    }
}

La logique du constructeur A(String test) et check() sont les choses que je suis en train d'essayer de se moquer. Je veux tout les appels de ce genre: new A($$$any string$$$).check() renvoie à un mannequin de la chaîne "test".

J'ai essayé:

 A a = mock(A.class); 
 when(a.check()).thenReturn("test");

 String test = a.check(); //to this point, everything works. test shows as "tests"

 whenNew(A.class).withArguments(Matchers.anyString()).thenReturn(rk);
 //also tried:
 //whenNew(A.class).withParameterTypes(String.class).withArguments(Matchers.anyString()).thenReturn(rk);

 new A("random string").check();  //this doesn't work

Mais il ne semble pas fonctionner. new A($$$any string$$$).check() est toujours en cours à travers la logique constructeur au lieu de chercher des mocks objet de A.

est votre moqué cochez() la méthode de travail de droit?
check() fonctionne bien. Juste le whenNew ne semble pas de travail du tout. J'ai mis à jour la description ainsi.

InformationsquelleAutor Shengjie | 2012-11-13

Le code que vous avez posté ne fonctionne pour moi avec la dernière version de Mockito et Powermockito. Peut-être que vous n'avez pas préparé?
Essayez ceci:

A.java

public class A {
     private final String test;

    public A(String test) {
        this.test = test;
    }

    public String check() {
        return "checked " + this.test;
    }
}

MockA.java

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest(A.class)
public class MockA {
    @Test
    public void test_not_mocked() throws Throwable {
        assertThat(new A("random string").check(), equalTo("checked random string"));
    }
    @Test
    public void test_mocked() throws Throwable {
         A a = mock(A.class); 
         when(a.check()).thenReturn("test");
         PowerMockito.whenNew(A.class).withArguments(Mockito.anyString()).thenReturn(a);
         assertThat(new A("random string").check(), equalTo("test"));
    }
}

Les deux tests doivent passer avec mockito 1.9.0, powermockito 1.4.12 et junit 4.8.2

Notez également que si le constructeur est appelé à partir d'une autre classe, de l'inclure dans la liste en PrepareForTest
Quelqu'un a une idée pourquoi devrions-nous nous préparer à l'auto quand "PowerMockito.whenNew" est appelé?

InformationsquelleAutor Alban

44

À ma connaissance, vous ne pouvez pas se moquer de constructeurs avec mockito, seules les méthodes. Mais, d'après le wiki sur le Mockito google code de la page, il y a une façon de se moquer du constructeur problème en créant une méthode dans votre classe qui retourne une nouvelle instance de cette classe. ensuite, vous pouvez se moquer que de la méthode. Ci-dessous est un extrait directement à partir de la Mockito wiki:
Modèle 1 - à l'aide d'une ligne de méthodes pour la création d'un objet

D'utiliser le motif 1 (test d'une classe Maclasse), vous devez remplacer un appel comme
```
   Foo foo = new Foo( a, b, c );
```
avec
```
   Foo foo = makeFoo( a, b, c );
```
et écrire une seule ligne de la méthode
```
   Foo makeFoo( A a, B b, C c ) { 
        return new Foo( a, b, c );
   }
```
Il est important que vous ne comprennent pas la logique de la méthode; il suffit d'une ligne qui crée l'
objet. La raison pour cela est que la méthode elle-même ne va jamais
à l'unité testée.

Quand vous venez de tester la classe, l'objet de test
en fait être un Mockito espion, avec cette méthode substituée, pour revenir un
se moquer. Ce que vous testez est donc pas la classe elle-même, mais un
très légèrement version modifiée.

Votre classe de test peut contenir des membres comme
```
  @Mock private Foo mockFoo;
  private MyClass toTest = spy(new MyClass());
```
Enfin, à l'intérieur de votre méthode d'essai vous moquer de l'appel à
makeFoo avec une ligne comme
```
  doReturn( mockFoo )
      .when( toTest )
      .makeFoo( any( A.class ), any( B.class ), any( C.class ));
```
Vous pouvez utiliser les allumettes qui sont plus précis que n'importe quel() si vous voulez
vérifier les arguments qui sont passés au constructeur.
Si vous êtes juste de vouloir y retourner un moqué objet de votre classe, je pense que cela devrait fonctionner pour vous. En tout cas vous pouvez lire plus au sujet de moqueries de la création d'objet ici:

http://code.google.com/p/mockito/wiki/MockingObjectCreation
- +1, je n'aime pas le fait que je dois ajuster mon code source, de le rendre plus mockito sympathique. Merci pour le partage.
- Il n'est jamais mauvais d'avoir le code source qui est plus testable, ou pour éviter la testabilité des anti-modèles lorsque vous écrivez votre code. Si vous écrivez de la source, ce qui est plus testable, il est automatiquement plus maintenable. Isoler votre constructeur appelle dans leurs propres méthodes est juste une façon d'atteindre cet objectif.
InformationsquelleAutor Ben Glasser

Sans L'Aide De Powermock .... Voir l'exemple ci-dessous, selon Ben Glasser réponse, car il m'a fallu un certain temps pour le comprendre ..espérons que permet de gagner du temps ...

Classe D'Origine :

public class AClazz {

    public void updateObject(CClazz cClazzObj) {
        log.debug("Bundler set.");
        cClazzObj.setBundler(new BClazz(cClazzObj, 10));
    } 
}

Modifié Classe :

@Slf4j
public class AClazz {

    public void updateObject(CClazz cClazzObj) {
        log.debug("Bundler set.");
        cClazzObj.setBundler(getBObject(cClazzObj, 10));
    }

    protected BClazz getBObject(CClazz cClazzObj, int i) {
        return new BClazz(cClazzObj, 10);
    }
 }

De La Classe De Test

public class AClazzTest {

    @InjectMocks
    @Spy
    private AClazz aClazzObj;

    @Mock
    private CClazz cClazzObj;

    @Mock
    private BClazz bClassObj;

    @Before
    public void setUp() throws Exception {
        Mockito.doReturn(bClassObj)
               .when(aClazzObj)
               .getBObject(Mockito.eq(cClazzObj), Mockito.anyInt());
    }

    @Test
    public void testConfigStrategy() {
        aClazzObj.updateObject(cClazzObj);

        Mockito.verify(cClazzObj, Mockito.times(1)).setBundler(bClassObj);
    }
}

InformationsquelleAutor user666

4

Mockito a des limites de test final, statique, et les méthodes privées.

avec jMockit bibliothèque de test, vous pouvez faire quelques trucs très facile et simple comme ci-dessous:

Maquette constructeur de java.io.Fichier de classe:
```
new MockUp<File>(){
    @Mock
    public void $init(String pathname){
        System.out.println(pathname);
        //or do whatever you want
    }
};
```
- le constructeur public nom doit être remplacé par $init
- arguments et les exceptions levées reste la même
- type de retour doit être défini comme nulle
Se moquer d'une méthode statique:
- supprimer les parasites de la méthode se moquer de la signature
- signature de la méthode reste la même sinon
InformationsquelleAutor Anamika

Vous devez vous connecter pour publier un commentaire.