Mocking des variables membres d'une classe à l'aide de Mockito

Je suis un novice en développement et en tests unitaires en particulier. Je suppose que mon exigence est assez simple, mais je souhaite connaître l'opinion des autres à ce sujet.

Supposons que j'ai deux classes comme ça -

public class First {

    Second second ;

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

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

class Second {

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

Disons que j'écris un test unitaire pour tester First.doSecond() méthode de . Cependant, supposons que je veuille moquer la Second.doSecond()classe comme ça. J'utilise Mockito pour ce faire.

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

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

Je vois que la moquerie n'a pas d'effet et que l'assertion échoue. N'existe-t-il aucun moyen de se moquer des variables membres d'une classe que je souhaite tester. ?

Vous devez fournir un moyen d'accéder aux variables membres afin de pouvoir passer dans un simulacre (les moyens les plus courants seraient une méthode setter ou un constructeur qui prend un paramètre).

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

Ce n'est pas possible si vous ne pouvez pas modifier votre code. Mais j'aime l'injection de dépendances et Mockito le prend en charge:

public class First {    
    @Resource
    Second second;

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

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

Votre test:

@RunWith(MockitoJUnitRunner.class)
public class YourTest {
   @Mock
   Second second;

   @InjectMocks
   First first = new First();

   public void testFirst(){
      when(second.doSecond()).thenReturn("Stubbed Second");
      assertEquals("Stubbed Second", first.doSecond());
   }
}

C'est très agréable et facile.

Si vous regardez attentivement votre code, vous verrez que la secondpropriété de votre test est toujours une instance de Second, pas une simulation (vous ne transmettez pas la simulation firstdans votre code).

Le moyen le plus simple serait de créer un setter pour seconden Firstclasse et de lui passer explicitement le simulacre.

Comme ça:

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

Un autre serait de passer une Secondinstance en tant que Firstparamètre de constructeur de.

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, car il est rare de faire des tests sur du code que vous ne contrôlez pas (bien que l'on puisse imaginer un scénario où vous devez tester une bibliothèque externe car son auteur ne l'a pas fait :))

Si vous ne pouvez pas modifier la variable membre, l'inverse est d'utiliser powerMockit et d'appeler

Second second = mock(Second.class)
when(second.doSecond()).thenReturn("Stubbed Second");
whenNew(Second.class).withAnyArguments.thenReturn(second);

Maintenant, le problème est que TOUT appel à new Second renverra la même instance simulée. Mais dans votre cas simple, cela fonctionnera.

J'ai eu le même problème où une valeur privée n'était pas définie car Mockito n'appelle pas les super constructeurs. Voici comment j'augmente la moquerie par la réflexion.

Tout d'abord, j'ai créé une classe TestUtils qui contient de nombreux outils utiles, y compris ces méthodes de réflexion. L'accès à la réflexion est un peu bancal à mettre en œuvre à chaque fois. J'ai créé ces méthodes pour tester du code sur des projets qui, pour une raison ou une autre, n'avaient pas de package moqueur et je n'ai pas été invité à l'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);
        }
    }

}

Ensuite, je peux tester la classe avec une variable privée comme celle-ci. Ceci est utile pour se moquer des arbres de classes que vous n'avez pas de contrôle également.

@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 actuel ici, en page. Il pourrait y avoir un problème de compilation ou deux. Je pense que vous avez une idée générale. N'hésitez pas à saisir le code et à l'utiliser si vous le trouvez utile.

Beaucoup d'autres vous ont déjà conseillé de repenser votre code pour le rendre plus testable - de bons conseils et généralement plus simples que ce que je suis sur le point de suggérer.

Si vous ne pouvez pas modifier le code pour le rendre plus testable, PowerMock: https://code.google.com/p/powermock/

PowerMock étend Mockito (vous n'avez donc pas besoin d'apprendre un nouveau framework fictif), fournissant des fonctionnalités supplémentaires. Cela inclut la possibilité qu'un constructeur renvoie une maquette. Puissant, mais un peu compliqué - alors utilisez-le judicieusement.

Vous utilisez un autre coureur Mock. Et vous devez préparer la classe qui va appeler le constructeur. (Notez qu'il s'agit d'un piège courant - préparez la classe qui appelle le constructeur, pas la classe construite)

@RunWith(PowerMockRunner.class)
@PrepareForTest({First.class})

Ensuite, dans votre configuration de test, vous pouvez utiliser la méthode whenNew pour que le constructeur renvoie un simulacre

whenNew(Second.class).withAnyArguments().thenReturn(mock(Second.class));

Oui, cela peut être fait, comme le montre le test suivant (écrit avec l'API de simulation JMockit, 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, un tel test ne peut pas être écrit. Cela est dû à la façon dont la moquerie est implémentée dans Mockito, où une sous-classe de la classe à moquer est créée; seules les instances de cette sous-classe «fictive» peuvent avoir un comportement simulé, vous devez donc faire en sorte que le code testé les utilise au lieu de toute autre instance.

Si vous voulez une alternative à ReflectionTestUtils de Spring dans mockito, utilisez

Whitebox.setInternalState(first, "second", sec);