Se moquant de variables membres d'une classe à l'aide de Mockito

Vous avez besoin de fournir un moyen d'accéder à des variables de membre de sorte que vous pouvez passer à une simulation (les façons les plus courantes serait un poseur de méthode ou d'un constructeur qui prend un paramètre).

Si votre code ne fournit pas un moyen de le faire, il est correctement compte pour le TDD (Test Driven Development).

Si vous regardez de près votre code, vous verrez que le second propriété dans votre test est toujours une instance de Second, pas un simulacre (vous ne passez pas le simulacre de first dans votre code).

La façon la plus simple serait de créer un setter pour second dans First classe et la passer à la maquette explicitement.

Comme ceci:

public class First {

Second second ;

public First(){
    second = new Second();
}

public String doSecond(){
    return second.doSecond();
}

    public void setSecond(Second second) {
    this.second = second;
    }


}

class Second {

public String doSecond(){
    return "Do Something";
}
}

....

public void testFirst(){
Second sec = mock(Second.class);
when(sec.doSecond()).thenReturn("Stubbed Second");


First first = new First();
first.setSecond(sec)
assertEquals("Stubbed Second", first.doSecond());
}

Une autre serait de passer un Second instance First's paramètre du constructeur.

Si vous ne pouvez pas modifier le code, je pense que la seule option serait d'utiliser la réflexion:

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");


    First first = new First();
    Field privateField = PrivateObject.class.
        getDeclaredField("second");

    privateField.setAccessible(true);

    privateField.set(first, sec);

    assertEquals("Stubbed Second", first.doSecond());
}

Mais vous pouvez probablement, comme il est rare de faire des tests sur le code, vous n'avez pas le contrôle (même si on peut imaginer un scénario où vous avez pour tester une bibliothèque externe car il est auteur ne l'a pas :))

J'ai eu le même problème où une valeur privée n'a pas été réglée parce que Mockito n'appelle pas super constructeurs. Voici comment j'ai augmenter moqueur avec la réflexion.

Tout d'abord, j'ai créé un TestUtils classe qui contient de nombreux utilitaires dont ces méthodes de réflexion. La réflexion de l'accès est un peu bancale à mettre en œuvre à chaque fois. J'ai créé ces méthodes pour tester le code sur des projets qui, pour une raison ou une autre, n'avait pas de moqueries paquet et je n'ai pas été invité à inclure.

public class TestUtils {
//get a static class value
public static Object reflectValue(Class<?> classToReflect, String fieldNameValueToFetch) {
try {
Field reflectField  = reflectField(classToReflect, fieldNameValueToFetch);
reflectField.setAccessible(true);
Object reflectValue = reflectField.get(classToReflect);
return reflectValue;
} catch (Exception e) {
fail("Failed to reflect "+fieldNameValueToFetch);
}
return null;
}
//get an instance value
public static Object reflectValue(Object objToReflect, String fieldNameValueToFetch) {
try {
Field reflectField  = reflectField(objToReflect.getClass(), fieldNameValueToFetch);
Object reflectValue = reflectField.get(objToReflect);
return reflectValue;
} catch (Exception e) {
fail("Failed to reflect "+fieldNameValueToFetch);
}
return null;
}
//find a field in the class tree
public static Field reflectField(Class<?> classToReflect, String fieldNameValueToFetch) {
try {
Field reflectField = null;
Class<?> classForReflect = classToReflect;
do {
try {
reflectField = classForReflect.getDeclaredField(fieldNameValueToFetch);
} catch (NoSuchFieldException e) {
classForReflect = classForReflect.getSuperclass();
}
} while (reflectField==null || classForReflect==null);
reflectField.setAccessible(true);
return reflectField;
} catch (Exception e) {
fail("Failed to reflect "+fieldNameValueToFetch +" from "+ classToReflect);
}
return null;
}
//set a value with no setter
public static void refectSetValue(Object objToReflect, String fieldNameToSet, Object valueToSet) {
try {
Field reflectField  = reflectField(objToReflect.getClass(), fieldNameToSet);
reflectField.set(objToReflect, valueToSet);
} catch (Exception e) {
fail("Failed to reflectively set "+ fieldNameToSet +"="+ valueToSet);
}
}
}

Alors je peux tester la classe avec une variable privée de ce genre. Ceci est utile de se moquer de profondeur dans la classe des arbres que vous n'avez aucun contrôle ainsi.

@Test
public void testWithRectiveMock() throws Exception {
//mock the base class using Mockito
ClassToMock mock = Mockito.mock(ClassToMock.class);
TestUtils.refectSetValue(mock, "privateVariable", "newValue");
//and this does not prevent normal mocking
Mockito.when(mock.somthingElse()).thenReturn("anotherThing");
//... then do your asserts
}

J'ai modifié mon code de mon projet ici, dans la page. Il pourrait y avoir une compilation question ou deux. Je pense que vous avez l'idée générale. Hésitez pas à saisir le code et l'utiliser si vous le trouvez utile.

Oui, cela peut être fait, comme le test suivant montre (écrit avec le JMockit se moquant de l'API, que je développe):

@Test
public void testFirst(@Mocked final Second sec) {
new NonStrictExpectations() {{ sec.doSecond(); result = "Stubbed Second"; }};
First first = new First();
assertEquals("Stubbed Second", first.doSecond());
}

Avec Mockito, cependant, qu'un tel test ne peut pas être écrit. Cela est dû à la façon dont se moquant est mis en œuvre dans Mockito, d'où une sous-classe de la classe se moque de lui est créé; les instances de cette "fantaisie" sous-classe peut avoir moqué de comportement, de sorte que vous besoin d'avoir le code à tester les utiliser à la place de toute autre instance.