Unité de test pour la méthode qui appelle plusieurs autres méthodes utilisant Mockito

J'ai peut-être complètement tombé court dans ma recherche, mais je ne peux pas trouver de la documentation ou des discussions relatives à la façon d'écrire un test unitaire pour une classe Java/méthode qui appelle à son tour à d'autres non-méthodes privées. Apparemment, Mockito prend la position qu'il y a peut-être quelque chose de mal avec le design (pas vraiment OO) si un espion doit être utilisé afin de tester une méthode où se moquant interne les appels de méthode est nécessaire. Je ne suis pas certain que c'est toujours vrai. Mais à l'aide d'un espion semble être le seul moyen d'accomplir cela. Par exemple, pourquoi ne pourriez-vous pas avoir un "wrapper" style de méthode qui s'appuie à son tour sur d'autres méthodes pour primitives les fonctions mais fournit en plus de la fonctionnalité, la gestion des erreurs, l'exploitation forestière, ou les différentes branches dépend des résultats des autres méthodes, etc.?

Donc ma question est double:

  1. Est mal conçu et mis en œuvre le code d'une méthode qui appelle en interne par d'autres méthodes?
  2. Quelle est la meilleure pratique et/ou d'approche dans l'écriture d'un test unitaire pour une telle méthode (en supposant qu'il est en soi une bonne idée), si l'on a choisi Mockito que leurs moqueries cadre?

Cela peut être difficile, mais je préférerais, pour ceux qui décident de répondre à pas simplement re-publier le Mockito verbiage et/ou de la position sur les espions que j'y suis déjà au courant de cette démarche et de l'idéologie. Aussi, j'ai utilisé Powermockito. Pour moi, le problème ici est que Mockito développé ce cadre, où les autres solutions ont dû être créés pour prendre en charge ce besoin. Donc je suppose que la question que je suis en voulant une réponse est de savoir si les espions sont "mauvais", et Powermockito n'étaient pas disponibles, comment est-on censé unité de tester une méthode qui appelle d'autres non-méthodes privées?

Tout code qui a des méthodes publiques de l'appel d'autres méthodes publiques (OK, peut-être à l'exclusion des getters et setters) devraient être examinés pour la violation potentielle de la GIFLE principe et/ou à la poubelle barge antipattern.
Auriez-vous l'esprit de partage certaines sources fiables quant à cette information?
Ici, vous allez: ibm.com/developerworks/java/library/j-eaed4/index.html et drdobbs.com/four-wheel-drive-garbage-barges-and-obje/184414617 .

OriginalL'auteur aquacode | 2012-09-27

  1. 7

    Est mal conçu et mis en œuvre le code d'une méthode qui appelle en interne par d'autres méthodes?

    Pas vraiment. Mais je dirais que, dans cette situation, la méthode qui appelle les autres devraient être testés comme si les autres, si ce n'est déjà testé séparément.
    C'est, il vous protège contre les situations où vos méthodes publiques s'arrête appelant les autres sans que vous vous en rendiez compte.

    Oui, il en fait (parfois) beaucoup de code de test. Je crois que c'est le point: la douleur dans l'écriture de tests est une bonne idée que vous pourriez envisager l'extraction de ces sous-méthodes dans une classe séparée.

    Si je peux vivre avec ces tests, puis-je considérer que la sous-méthodes ne doivent pas être extraites encore.

    Quelle est la meilleure pratique et/ou d'approche dans l'écriture d'un test unitaire pour une telle méthode (en supposant qu'il est en soi une bonne idée), si l'on a choisi Mockito que leurs moqueries cadre?

    Je ferais quelque chose comme ça:

    public class Blah {
    public int publicMethod() {
        return innerMethod();
    }

    int innerMethod() {
        return 0;
    }
}


public class BlahTest {
    @Test
    public void blah() throws Exception {
        Blah spy = spy(new Blah());
        doReturn(1).when(spy).innerMethod();

        assertThat(spy.publicMethod()).isEqualTo(1);
    }
}

    OriginalL'auteur Eric

  2. 2

    Si vous en avez vraiment besoin (ou envie) pour éviter l'appel de la baisse du niveau des méthodes de nouveau, vous pouvez stub eux au lieu de se moquer d'eux. Par exemple, si la méthode A appelle B et C, vous pouvez le faire:

    MyClass classUnderTest = new MyClass() {
    @Override
    public boolean B() {return true;}

    @Override
    public int C() {return 0;}
};
doOtherCommonSetUp(classUnderTest);
String result = classUnderTest.A("whatever");
assertEquals("whatIWant", result);

    J'ai utilisé ce tout à fait un peu avec le code existant, où de nombreuses refactoring pourrait facilement conduire à la version du logiciel de charpentier de marine de la maladie: Isoler quelque chose de difficile à tester dans une petite méthode, puis stub.

    Mais si les méthodes sont appelés sont assez anodins et ne nécessitant pas se moquer, je viens de laisser être appelée de nouveau, sans se soucier que je suis couvrant toutes les chemin dans.

    OriginalL'auteur jalynn2

  3. 2

    Pour moi, cette question est fortement liée à la notion de cohésion.

    Ma réponse serait:

    C'est ok pour avoir des méthodes (public) qui appellent d'autres méthodes (privé) dans une classe, en fait, très souvent, c'est ce que je pense de bon code. Il y a un inconvénient de cette cependant, dans votre classe doit encore être fortement cohésive. Pour moi, cela signifie que l'état de votre classe doivent être bien définis, et les méthodes (pensez comportements) de votre classe doit être impliqués dans l'évolution de vos classes de l'état de manière prévisible.

    Est-ce le cas avec ce que vous êtes en train de tester? Si non, vous pouvez être à la recherche d'une classe lorsque vous devriez être à la recherche à deux (ou plus).

    Quelles sont les variables d'état de la classe que vous soyez en train de tester?

    Vous trouverez peut-être que après avoir examiné les réponses à ces types de questions, votre code devient beaucoup plus facile de tester la façon dont vous pensez qu'elle devrait être.

    OriginalL'auteur John Deverall

  4. 2

    La vraie question devrait être:

    De quoi ai-je vraiment envie de tester?

    Et en fait la réponse devrait être:

    Le comportement de mon objet en réponse à l'extérieur des changements

    Qui est, selon la façon dont on peut interagir avec un objet, vous souhaitez tester chaque scénario unique dans un seul test. De cette façon, vous pouvez vous assurer que votre classe réagit en fonction de vos attentes, selon le scénario que vous êtes offrant à vos tests.

    Est mal conçu et mis en œuvre le code d'une méthode qui appelle en interne par d'autres méthodes?

    Pas vraiment, et vraiment pas! Ces soi-disant privées, des méthodes qui sont appelées à partir de membres publics sont à savoir les méthodes d'aide. Il est tout à fait correcte pour avoir les méthodes d'aide!

    Méthodes d'assistance sont là pour aider à briser certains des comportements plus complexes en petits morceaux de code réutilisable à partir de l'intérieur de la classe elle-même. Seulement, il sait comment il doit se comporter et de retour à l'état en conséquence par le public et les membres de votre classe.

    Il est unrare de voir une classe avec des méthodes d'assistance et normalement, ils sont nécessaires à l'adoption d'un comportement interne pour lequel la classe ne devrait pas réagir du monde extérieur.

    Quelle est la meilleure pratique et/ou d'approche dans l'écriture d'un test unitaire pour une telle méthode (en supposant qu'il est en soi une bonne idée), si l'on a choisi Mockito que leurs moqueries cadre?

    À mon humble avis, vous n'avez pas de tester ces méthodes. Ils obtiennent à l'épreuve lorsque les membres du public sont testés par le biais de l'état que vous attendez de votre objet sur un membre du public d'appel. Par exemple, en utilisant le modèle MVP, si vous voulez tester l'authentification de l'utilisateur, vous ne pouvez pas tester toutes les méthodes privées, puisque les méthodes privées pourrait aussi bien appeler d'autres méthodes publiques à partir d'un objet dont dépendent l'objet sous test, et ainsi de suite. Au lieu de cela, le test de votre vue:

    @TestFixture
public class TestView {
    @Test
    public void test() {
        //arrange
        string expected = "Invalid login or password";
        string login = "SomeLogin";
        string password = "SomePassword";

        //act
        viewUnderTest.Connect(login, password);
        string actual = viewUnderTest.getErrorMessage;

        //assert
        assertEqual(expected, actual);
    }
}

    Cette méthode d'essai décrit le comportement attendu de votre point de vue, une fois les, disons, connectButton est cliqué. Si le ErrorMessage propriété ne contient pas la valeur attendue, cela signifie que soit votre point de vue ou le présentateur ne se comporte pas comme prévu. Vous pouvez vérifier si le présentateur abonné à votre vue Connect de l'événement, ou si votre animateur définit le droit de message d'erreur, etc.

    Le fait est que vous n'avez jamais besoin de tester tout ce qui se passe dans vos méthodes privées, comme vous allez le régler et d'apporter des corrections sur le débogage, qui à son tour vous fait pour tester le comportement de vos méthodes internes simultanément, mais aucune méthode de test doivent être écrites expressément pour ceux de la méthode d'assistance.

    OriginalL'auteur Will Marcouiller