Comment réutiliser les tests JUnit dans une autre classe de test?

comment puis-je réutiliser JUnit tests dans un autre testclass?

Par exemple:

public TestClass1 {
    @Test
    public void testSomething(){...}
}

public TestClass2 {
    @Test
    public void testSomethingAndSomethingElse() {
        //Somehow execute testSomething()
        //and then test something else
    }
}

Les tests unitaires doivent être indépendants et isolés. Faire un test dépend d'un autre est une mauvaise idée.
cas d'utilisation: votre app/framework prend en charge plusieurs bases de données. si vous avez une base de test de la classe qui contient des tests pour toutes les fonctionnalités et une prolongation par la base de données qui crée la connexion, les charges initial DDL/données, etc.
Ses une mauvaise idée et d'être parfois mauvaise, c'est bon 🙂

InformationsquelleAutor tk2000 | 2013-06-17

Comme d'habitude, vous pouvez:

S'étend TestClass2 de TestClass1
Accès TestClass1 de TestClass2 à l'aide de la délégation:

Exemple 1:

//Instantiate TestClass1 inside test method
public TestClass2 {
    public void testSomethingAndSomethingElse1() {
         new TestClass1().testSomething();
    }
}

Exemple 2:

//Instantiate TestClass1 as a member of TestClass2
public TestClass2 {
    private TestClass1 one = new TestClass1();
    public void testSomethingAndSomethingElse1() {
         one.testSomething();
    }
}

InformationsquelleAutor AlexR

36

Éviter le scénario, en général. Il est sujet à faire des tests beaucoup plus fragile. Si TestClass1 échoue, alors TestClass2 implicitement échoue, ce qui n'est pas souhaitable pour au moins les raisons suivantes:
- Code est testé plus d'une fois, ce qui gaspille de temps d'exécution.
- Les Tests ne devraient pas compter les uns sur les autres, ils doivent être découplés que possible
- Si cela devient un modèle, il deviendra plus difficile de déterminer dans quelle section de code est cassé en regardant quels sont les tests à défaut, qui est partie du point de tests
Parfois de partage de sections de code de test est utile, en particulier pour les tests d'intégration. Voici comment vous pourriez le faire, sans, selon les tests eux-mêmes:
```
public abstract BaseTests {

    protected void somethingHelper() {
        //Test something
    }
}

public TestClass1 extends BaseTests {
    @Test
    public void testSomething(){
        somethingHelper();
    }
}

public TestClass2 extends BaseTests {
    @Test
    public void testSomethingAndSomethingElse() {
        somethingHelper();
        //and then test something else
    }
}
```
Sinon, vous pouvez utiliser une classe d'assistance et d'éviter l'héritage tout à fait. S'affirme et qui peuvent aller dans le somethingHelper() méthode.

Ne pas appeler une méthode de TestClass1 dans TestClass2 directement. Le cas de test deviennent moins lisibles de cette façon, et peut conduire à spaghetti frittata.
- Ce que vous avez dit est vrai pour les tests unitaires des cas. Quid de l'intégration ou de test fonctionnel des cas où les enfants sont les scénarios dépendent des parents scénarios et de chacun des frères et sœurs sont indépendants l'un de l'autre?
- Cette question est taggés "unité-tests", mais pour l'intégration ou fonctionnelle des cas de test de la deuxième moitié de ma réponse s'applique. Les Sections de code de test peuvent être partagées pour cet effet. La clé est d'éviter d'appeler un test directement à partir d'un autre, au lieu de passer le code partagé dans une classe de base ou à un accompagnateur. Cela permet de savoir exactement ce que les sections de la suite de test sont partagés.
- Je suis face à un scénario où je voudrais faire en sorte que des Tests spécifiques sont encore en cours d'exécution et de passage et qui n'ont pas été supprimés (l'associé dev changement de code à supprimer certains de ces composants) penseriez-vous de ce qui s'appelle un scénario où je pourrais appeler sur les tests existants et s'assurer qu'ils sont toujours là et bien? Sinon, ils pourraient venez de supprimer par accident et de la suite de test ne serait pas en panne à tous
InformationsquelleAutor seanhodges
2

Ce qui est commun à l'exécution d'un test avec une configuration différente. Ne vous inquiétez pas à ce sujet et aller de l'avant.

À la première étape, créez votre propre test sans tenir compte de la configuration:
```
public abstract BaseTests {
    @Test
    protected void somethingHelper() {
        //Test something
    }
}
```
Ensuite, étendre la classe de test et ajouter un peu de configuration:
```
public TestClass1 extends BaseTests {
    @Before
    public void setup(){
         //TODO: config
    }
}
```
Il n'est pas nécessaire de faire la configuration spécifique mais il est très fréquent, avec un système configurable (la principale fonctionnalité du système doit être valide pour chaque config).

Dans les autres cas de test:
```
public TestClass2 extends BaseTests {
    @Before
    public void setup(){
         //TODO: other config
    }
}
```
Par exemple, il peut être un chiffrement et le déchiffrement processus où la séquence de chiffrement>le déchiffrement doit être identifié. D'autre part, il existe un autre algorithme à utiliser pendant le processus de test est unique.

InformationsquelleAutor Mostafa
1

Logiquement, il n'y a pas de raison d'appeler une méthode de test à partir d'un autre. Tout outil qui exécute un test juste comme facilement tous les tests dans le package. Mais si vous en avez besoin, vous souhaitez appeler comme toute autre méthode dans une autre classe.

Ce que vous avez probablement envie de faire, est de procéder à certaines communes pour les deux méthodes d'essai. Vous pourriez mettre that code dans une méthode utilitaire dans une classe commune, et d'invoquer le code commun dans les deux tests.
- cas d'utilisation: votre app/framework prend en charge plusieurs bases de données. si vous avez une base de test de la classe qui contient des tests pour toutes les fonctionnalités et une prolongation par la base de données qui crée la connexion, les charges initial DDL/données.
- Le pré-chargement des données est une étape de configuration. Il ne devrait pas faire partie d'un cas de test, mais une condition préalable pour tous les cas de test.
- C'est environ 10% de ce que je parlais. Le cas de test aura beaucoup, beaucoup de cas de test que vous devez exécuter pour chaque base de données dont vous avez besoin de soutien. Il est inutile de dupliquer ce code.
- Je n'ai jamais dit que les cas de test doivent être dupliquées. Je veux dire que la relation doit être autre que des cas de test en appelant les uns les autres. Vous pourriez avoir différentes Suites de tests qui utilisent le même cas de test avec un ensemble différent de conditions préalables chaque. Sinon, la modélisation est tout simplement faux.
- Mon exemple est un exemple parfait pour l'utilisation de OO à organiser des tests. Pas de suites de test, de piratage ou autre magie nécessaire. Le résumé de la base de test est un résumé getConnection() méthode et tout le reste est héréditaire. Si une fonctionnalité n'est pas le support pour une certaine base de données, vous pouvez facilement l'exclure en la remplaçant.
- Oh, que est ce que tu voulais dire par extension. Oui, à l'aide d'une classe de base abstraite œuvres. Mon point était que "l'appel" est mauvais. L'OP n'a pas dit pourquoi ils ont voulu le faire, alors je viens de répondre à leur question.
- Un autre cas d'utilisation: j'ai besoin de le faire parce que j'ai une grande quantité de tests dont l'accès à une base de données qui est mis en place comme une condition préalable. Je découvre qu'il y a peut être des dépendances entre les cas de test (et il ne devrait pas être) et suis en train d'isoler ces dépendances, alors je voudrais effectuer des tests ensemble sans totalement refactoring de mon projet. C'est tout simplement un temporaire mécanisme de débogage.
- c'est vraiment une bonne façon de partager le code de test entre les différentes implémentations de code sous test. Et ce n'est pas seulement utile pour les bases de données. Il permet à toutes les implémentations de l'interface de partager des tests. Elle vous permet d'établir que la mise en œuvre du code conforme au contrat d'une interface.
- Si vous êtes en utilisant les interfaces, alors vous devriez envisager d'utiliser JUnit règles.
InformationsquelleAutor Rajesh J Advani

Vous devez vous connecter pour publier un commentaire.