Discussion :

[leminipouce]

Bonjour tout le monde,

Je n'arrive pas à trouver un moyen de solidariser l'exécution de mes groupes de test avec TestNG.
Je m'explique, j'ai 3 groupes de tests, qui utilisent tous le même singleton. J'aimerais éviter les interactions d'un groupe sur les autres. Aussi je voudrais que chacun de mes groupes s'éxécute d'un bout à l'autre avant que ne commence le groupe suivant. Peu importe l'ordre d'exécution des dits groupes, du moment que chacun s'exécute de manière "transactionnelle".

Savez-vous s'il existe une solution pour parvenir à mes fins ? Car pour l'instant j'ai un bout du premier groupe qui s'exécute, puis un bout du second, un bout du premier à nouveau, un bout du troisième... etc

Par avance, Merci pour votre aide,

Pouce.

[Deaf]

Bonjour,

Il faut que tu introduises la notion de dépendance.
Si j'ai bien compris ce que tu veux, tu dois ajouter:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

@Test(groups="group1",)

sur toutes tes méthodes de test de ton premier groupe.
Et:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

@Test(groups="group2", dependsOnGroups = "group1")

sur toutes les méthodes de test de ton second groupe.

Je t'épargne l'annotation des méthodes de ton 3e groupe

Si tu es en JDK1.4, ce sont des tags javadoc similaire qu'il fait utiliser si ma mémoire est bonne. Mais le principe reste le même.

[leminipouce]

Salut et merci pour ta réponse,

En effet, mettre des dépendances entre les groupes fonctionne bien, mais ce n'est pas ça que je veux (j'avoue que c'est ce que j'ai en place en ce moment en solution paliative mais bon...).

L'idée c'est que chacun de mes groupes est totalement indépendant des autres. Pour de tests d'intégration les rendre dépendant et vérifier qu'ensemble ils fonctionnent bien, ça me va, par contre pour des TU, non.
Disons qu'en plus d'exécuter ma suite de tests, je voudrais pouvoir tester chacun des groupes individuellement. Les dépendances impliquent que je les teste en suite. Et si je mets un groupe à jour, je voudrais pouvoir vérifier son fonctionnement avant de l'intégrer avec les autres groupes.

PS : Je suis en JDK6, sous Eclipse 3.4, et je peux lancer ma suite soit avec le plugin testng d'Eclipse, soit avec Maven 2.1.

Cdlt,
Pouce.

[Deaf]

Si cela ne te convient pas, c'est que je n'ai pas compris ce que tu voulais, et ta réponse ne m'a pas aidé à mieux comprendre

Pourrais-tu être plus précis sur ce que tu veux exactement? Un exemple avec deux groupes de deux tests (par exemple) pourrait peut-être illustrer tout ça.

[leminipouce]

OK... alors voici un peu de code

Prenons un premier groupe : referentiel.config

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
    /**
     * On définit quel est le fichier qui va être utilisé pour ce référentiel de conf.
     */
    public void defineXmlFile() {
        // On définit dans quel fichier vont se faire les écritures de ce test
        siloB.setXmlFile(XML_FILE);
 
        // Et on instancie le Silo en fonction de ce fichier XML.
        createSilo();
    }
 
    /**
     * Test de remplissage du modèle de référentiel de configuration du Silo.
     */
    @Test(groups = {"functest", "referentiel.config"})
    public void testPopulateModel() {
        // On définit le XML et on crée le Silo.
        defineXmlFile();
 
        // On valide qu'il y a bien des données dans le Silo
        checkSiloFull();
    }
 
   /**
     * Test que la récupération d'un paramètre dont le nom n'est pas connu lève une exception
     */
    @Test(groups = {"functest", "referentiel.config"}, expectedExceptions = {ParamNotFoundException.class}, dependsOnMethods = {"testPopulateModel"})
    public void testInvalidParam() {
        // Accès à un paramètre dont le nom n'est pas valide.
        siloB.getParam(INVALID_PARAM);
    }

Dans ce premier groupe j'effectue divers tests permettant de valider des accès sur un fichier XML (appelé référentiel de conf et correspondant à un Silo), définit dans la méthode defineXmlFile().

Prenons désormais, un autre groupe : referentiel.saj. Je teste dans ce second groupe l'implémentation d'une API d'accès à ce référentiel de conf.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    /**
     * On définit quel est le fichier qui va être utilisé pour ce référentiel de conf.
     */
    @Test(dependsOnGroups = {"referentiel.config"})
    public void defineXmlFile() {
        // On définit dans quel fichier vont se faire les écritures de ce test
        siloB.setXmlFile(XML_FILE);
 
        // Et on instancie le Silo en fonction de ce fichier XML.
        createSilo();
    }
 
    /**
     * Constructeur initialisant le modèle de test.
     */
    public TestAPISajImpl() {
        setParamSajEcriture(new ParamSajEcritureImpl());
        setParamSajLecture(new ParamSajLectureImpl());
        setSiloB(SiloB.getInstance());
    }
 
    /**
     * Test d'ajout d'une application au Silo.
     */
    @Test(groups = {"functest", "referentiel.saj"}, dependsOnMethods = {"defineXmlFile"})
    public void testAddApp() {
        paramSajEcriture.addApplication(APP_NAME_1);
 
        siloB.writeModel();
    }
 
    /**
     * Test de présence d'une application.
     */
    @Test(groups = {"functest", "referentiel.saj"}, dependsOnMethods = {"testAddApp"})
    public void testReadApp() {
        siloB.clearSilo();
        siloB.loadModel();
 
        Assert.assertEquals(paramSajLecture.getApplications().size(), 1);
    }

Il y a 3 API d'accès à ce référentiel de conf. Les accès des 3 API sur le référentiel sont croisées et toutes utilisent la même implémentation... qui se base sur l'implémentation de ma classe SiloB, qui est un singleton.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

setSiloB(SiloB.getInstance());

Pour éviter que les modifications sur le référentiel de conf effectuées par un de mes groupes de test n'est d'impact sur les autres groupes de tests, je définit un fichier XML pour mon référentiel de configuration différent pour chaque groupe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

siloB.setXmlFile(XML_FILE);

L'idée est que la méthode qui définit le fichier XML (defineXmlFile) doit forcément s'exécuter au début de chaque groupe. Mais comme elle accède au singleton SiloB, il ne faut surtout pas qu'un autre groupe démarre tant que le premier n'est pas terminé. Sinon, le fichier XML change... et les tests plante.

A ce jour, le fonctionnement @dependsOnMethods/@dependsOnGroups implique (par exemple) que la méthode testReadApp sera exécutée après testAddApp dans le groupe referentiel.saj, mais rien n'empêche qu'entre ces 2 méthodes il n'y ait pas les méthodes defineXmlFile puis testPopulateModel de mon groupe referentiel.config qui soient exécutées.


Si je fais des dépendances entre les groupes, aucun problème, les 2 s'enchaînent, mais je perds la possibilité d'exécuter l'un sans l'autre.

J'espère avoir réussi à être plus clair cette fois.

Cdlt,
Pouce.

[Deaf]

Je ne m'attendais pas spécialement à avoir du code, je dois t'avouer, mais juste à des exemples simples genre test1group1, etc.

Je vais résumer ce que je pense avoir compris, après on verra...

Tu as:
- un ensemble de méthodes de tests A, disons testA1, testA2, etc. que l'on appelera testA*
- un ensemble de méthodes de testB*
- une méthode initA qui doit être exécutée avant les testA*
- une méthode initB qui doit être exécutée avant les testB*

Si on joue initA, toutes les testA* doivent être jouées (dans n'importe quel ordre) avant que l'on puisse envisager de jouer initB).
Et inversement.

Sachant que cela t'es égal de jouer les A avant ou après les B (tant que ce qui précéde est respecté.

J'ai bon?

[leminipouce]

(Désolé pour le retard... j'ai pris un long week-end)

Sinon, tu as tout juste. Et tu as bien mieux résumé que moi.

Et c'est bien la partie

avant que l'on puisse envisager de jouer initB.
Et inversement.

qui me pose problème.

Avec également la contrainte que j'aimerais pouvoir garder les 2 groupes A et B indépendant l'un de l'autre pour pouvoir les exécuter soit l'un soit l'autre en "solitaire".

Pouce.

[Deaf]

Alors, je ne pense pas qu'il soit possible via les annotations testNG de lui dire fait le groupe A puis le groupe B ou l'inverse.

De là, tu as deux options:
- la plus simple est de décider que le groupe A sera avant le groupe B. tu fais dépendre tes testsA* de initA, ton initB de testsA* et tes testsB* de initB*.
- la plus "élaborée" consiste à implémenter un org.testng.IMethodInterceptor dans lequel tu modifies l'ordre "à la main". J'ai déjà eu à la faire parce que je voulais que les tests soient joués dans un ordre aléatoire. Mon but final était de lancer le test un grand nombre de fois afin de tester un maximum de combinaisons.

[leminipouce]

Damned!

C'est hélas bien ce que je craignais. Comme je te le disais dans un précédent post, je suis déjà parti sur l'option "la plus simple" que tu viens de décrire, histoire de pouvoir avancer. En plus d'être facile et rapide à mettre en oeuvre, elle a aussi l'avantage d'être débrayable très facilement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
@Test(dependsOnGroups = {"testsA"})
    // @Test

et il ne reste plus qu'à commenter/décommenter l'une ou l'autre des 2 lignes pour être libre d'exécuter les tests d'un seul groupe ou de toute la suite des groupes. (annotations présentes juste avant l'initB évidement)

Je vais laisser le post ouvert encore quelques jours pour voir si quelqu'un vient avec une autre solution.. sait-on jamais

En tout cas merci pour ton intérêt à ma question et tes réponses,

Pouce.