Paramétré test avec Mockito en utilisant JUnit @Règle?

Ce qui suit cette question: où suis-je demandé de commencer une nouvelle question.

Le problème est que je ne sais juste pas assez de JUnit Rule, ou qu'est-ce qui se passe ici avec Runners et comme, pour faire craquer le problème de la manière évoquée par Jeff Bowman.

Avez-vous passer par le tutoriel? vogella.com/tutorials/JUnit/article.html il a également une section pour les tests paramétrés
le point de ma question est que je veux utiliser Mockito, qui utilise sa propre RunWith annotation si vous le souhaitez (en particulier) afin d'injecter des simulacres. C'est le problème. J'ai des raisons de croire Jeff Bowman peut répondre à la question. Mais il voulait de moi pour commencer une nouvelle question...
Le tutoriel va répondre à toutes vos questions à propos de mockito. La question est: voulez-vous apprendre quelque chose ou voulez-vous une solution à copier?
bien que j'ai visité cette page, vous avez suggéré et recherché Mockito... il y a un lien à une "intro à Mockito". Mais je ne pouvais pas trouver n'importe où qui suggère une manière de faire de paramétrer les tests. En fait une solution de copie est, dans mon expérience, une excellente façon de commencer à apprendre qqch. Donc, si vous avez un exemple à me montrer, je serais très reconnaissant si vous pouviez répondre à la question.
Vous êtes tout à fait devenir ennuyeux maintenant. Vous ne pouvez pas combiner les deux RunWith annotations. Par conséquent, il n'est pas possible de combiner RunWith(MockitoJUnitRunner.class) avec RunWith(Parameterized.class). Vous avez besoin de penser à cela plutôt que de croire que les gens sont plus jeunes ou plus stupide que vous-même.

OriginalL'auteur mike rodent | 2016-11-24

21

Vos commentaires, j'ai compris l'écart: Vous devez utiliser Mockito comme une Règle et Paramétrés en tant que Coureur, pas l'inverse.

La raison en est que le Coureur est responsable de la déclaration du nombre de tests, et Paramétré manipule le nombre de tests basée sur le nombre de méthodes d'essai et le nombre d'entrées paramétrées, il est donc vraiment important pour Paramétré pour être une partie du processus Runner. En revanche, l'utilisation d'un Mockito coureur ou une règle est simplement pour encapsuler le @Before et @After méthodes d'initialiser Mockito d'annotations et de valider Mockito d'utilisation, ce qui peut être fait très facilement comme un @Rule qui fonctionne à côté d'autres @Rule instances--au point que le MockitoJUnitRunner est presque obsolète.

Au lit de bébé directement à partir de la JUnit4 Paramétré Test page de doc et MockitoRule page de doc:
```
@RunWith(Parameterized.class)
public class YourComponentTest {

    @Rule public MockitoRule rule = MockitoJUnit.rule();
    @Mock YourDep mockYourDep;

    @Parameters
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {     
                 { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 }  
           });
    }

    private int fInput;

    private int fExpected;

    public YourComponentTest(int input, int expected) {
        fInput = input;
        fExpected = expected;
    }

    @Test
    public void test() {
        //As you may surmise, this is not a very realistic example of Mockito's use.
        when(mockYourDep.calculate(fInput)).thenReturn(fExpected);
        YourComponent yourComponent = new YourComponent(mockYourDep);
        assertEquals(fExpected, yourComponent.compute(fInput));
    }
}
```
Brillant. Fonctionne comme un charme. C'est pourquoi nous avons besoin d'experts!
Est-il possible de se moquer des données? j'.e @Mock private int fInput ?
Bien sûr; je l'ai fait ci-dessus. Le paramétrage régit le nombre de fois où le test est exécuté et la façon dont la classe de test est instancié, et puis MockitoRule régit la façon dont @Mock paramètres sont remplies dans chaque cas de test (c'est à dire à l'intérieur de chaque classe de test exemple). Tant que le Paramétrée coureur est dans l' @RunWith annotation et Mockito l'initialisation se passe d'une manière ou d'une autre, les deux fonctionnent bien ensemble.

OriginalL'auteur Jeff Bowman

Vous devez vous connecter pour publier un commentaire.