Catégorie : Outils

Il était une fois une entreprise qui avait un système d’information. Dans ce système prospéraient différents applicatifs, plus ou moins récents et plus ou moins bien maintenus. Même s’ils formaient un ensemble hétéroclite et souvent assez bancal, tous ces applicatifs avaient bon nombre de points communs. Premièrement, ils parlaient souvent des mêmes choses (de « clients », de « contrats », de « factures », de « produits »…) Deuxièmement, ils étaient mal documentés, vraiment très mal documentés. Troisièmement, ils faisaient l’objet d’une lutte sans relâche : les équipes techniques refusaient de porter la connaissance fonctionnelle de ces outils, et les équipes fonctionnelles refusaient d’admettre que les équipes techniques ne connaissaient pas leurs règles de gestion.

Les problèmes de cette entreprise étaient aussi épineux que désespérément ordinaires.

Aujourd’hui, notre invité Rémi Le Brouster est avec nous pour parler d’une solution, nommée ODASE, visant à résoudre les problèmes de cette entreprise.

Hightest : Bonjour Rémi ! Tu es directeur technique adjoint de la solution ODASE, et tu étais précédemment développeur. Au cours de ta carrière, as-tu déjà été impliqué au sein d’une entreprise comme celle dont on parlait à l’instant ?

Rémi Le Brouster : Bonjour Hightest ! Ca m’est en effet arrivé, et c’est aussi pour cela que je me suis beaucoup investi pour rejoindre ODASE. J’ai été dans une entreprise très orientée métier, avec une problématique de migration d’un ancien logiciel vers un nouveau, où il fallait donc recouvrer et réimplémenter les règles de gestion. L’ancienne application datant, les spécialistes des différentes parties du métier n’étaient plus tous là, et ceux qui les avaient remplacés étaient parfois contraints de nous répondre de refaire pareil, faute de documentation métier suffisante, ce qui impliquait de fouiller dans le code…

Et évidemment, en voulant réimplémenter les comportements métiers, qu’ils soient historiquement bien réalisés ou fautifs, les développeurs introduisaient aussi de nouveau bugs, ce qui est le lot de presque tout développement.

Je pense également que ce genre de problématiques arrive dans beaucoup d’entreprises, mais avec le chef de service informatique / responsable R&D qui fait le tampon entre le métier et les développeurs, ce qui invisibilise le problème pour ces derniers.

H : Quel est l’objectif d’ODASE ?

RLB : L’objectif d’ODASE est de séparer intégralement le métier de la technique. Le métier doit être garant de la partie métier, tout comme les développeurs doivent se concentrer sur le code et ses problématiques techniques. Pour cela, il faut un outil capable de faire la passerelle entre les deux, se basant donc sur la documentation métier, et qui soit interrogeable via des applications, en leur retournant les résultats calculés souhaités. Cela permet aussi que cette documentation métier soit nécessairement à jour et en phase avec les applications.

Habituellement, dans les systèmes d’information :

• Les spécifications métier peuvent être éparpillées, redondantes, incomplètes, incorrectes, ambiguës.
• Le nombre de lignes de code peut être très important.
• Les changements dus au métier affectent toute l’implémentation.
• Ces changements métiers sont rarement bien documentés, bien qu’ils devraient l’être.
• Le debugging porte tant sur la technique que sur le métier puisque les experts métier n’ont pu intervenir en amont de l’implémentation.

Mettons qu’un SI ait un client lourd et une appli web, voici à quoi cela ressemble classiquement :

Avec ODASE, un certain nombre de choses changent.

• Le métier et la technique sont clairement séparés.
• Le métier est défini en un point unique (l’ontologie et les règles associées).
• L’ontologie est validée en amont avec les experts métier grâce aux explications.
• Il ne peut pas y avoir de contradictions entre le métier et l’implémentation technique.
• Le nombre de lignes de code est très réduit (il ne couvre que la technique).
• Les changements métier ne portent que sur l’ontologie.
• L’ontologie est une documentation de la vérité métier, toujours à jour.
• Les tests de type informatique ne portent que sur la technique.

On se retrouve donc avec une configuration comme suit :

H : Comment fonctionne ODASE ?

L’ontologie se découpe principalement en une représentation des concepts, de leurs attributs et de leurs liens entre eux, et en une spécifications des règles métiers qui définissent l’interaction entre ces différents éléments. Ces règles métiers sont des propositions logiques, ce qui signifient qu’elles sont tout le temps vraies, et qu’il n’y a aucune notion d’ordre entre elles.

H : Pour parler en langage de testeur, ODASE permet de réaliser une analyse statique automatisée du référentiel métier… C’est top ! 

On obtient ainsi une représentation du métier spécifique, compréhensible et validée par le métier, que l’on peut faire évoluer facilement.

H : Mettons qu’ODASE soit installé dans une entreprise où travaillent des testeurs. Quels sont les changements à prévoir dans le quotidien de ces testeurs ? Quelle interaction avec ODASE prévoyez-vous ?

RLB : Tout dépend du contexte. Par exemple, si les testeurs ont une bonne connaissance métier, il peut être pertinent pour l’ontologue d’échanger avec eux, pour essayer d’en extraire de la connaissance métier, en complément des autres sources disponibles.

Les testeurs peuvent également valider, dans les applications techniques, que les résultats obtenus sont les bons. En effet, même si le métier est juste, si les applications qui interrogent ODASE ne fournissent pas les bonnes informations, c’est-à-dire s’ils envoient une mauvaise valeur ou omettent une variable nécessaire dans la construction du JSON de la requête envoyée (dans le cas d’une architecture client/serveur), le résultat sera erroné. Dans cette continuité, les testeurs peuvent également porter leur attention sur l’évolution de l’API, par exemple suite à l’évolution des informations nécessaires d’un point de vue métier, pour tester que ces évolutions ont bien été prises en compte techniquement dans les applications.

H : Quels types de profils deviennent ontologue ?

RLB : Il s’agit en général de docteur·e·s en informatique spécialisé·e·s dans la représentation des connaissances.

H : L’approche d’ODASE rappelle celle du BDD (behavior driven development). Comment se situe ODASE vis-à-vis des outils de BDD ?

RLB : Notre approche étant basée sur des propositions logiques toujours vraies, elle est fondamentalement orientée état. Ainsi, il n’y a pas du tout la notion de « When » des scénarios « Given … When … Then … ». Un état partiel est transmis à ODASE, et ODASE complète le reste. Le comportement, lui, est implémenté au niveau de l’applicatif, de façon technique.

De même, nous cherchons à représenter la réalité métier, de façon indépendante des fonctionnements attendus. Ainsi, ce ne sont pas des tests à passer, ni une volonté stratégique, commerciale ou produit quelconque qui vont régir l’ontologie. La réalisation de l’ontologie est avant tout une quête de la plus pure réalité métier. Les choix ontologiques sont uniquement faits en ce sens. Par contre, on peut s’adapter pour modéliser une partie de cette réalité métier avant une autre.

H : Merci Rémi pour ton temps et tes explications !

Retrouvez l’intégration d’ODASE dans le quotidien des équipes techniques dans la deuxième partie de cet article !

Découvrir ODASE, partie II : intégrer les ontologies dans le SI

PS : Si vous souhaitez en savoir plus, voici l’adresse d’ODASE : info@odase.io

Vous gérez vos tests à l’aide de Xray, et vous avez des tests automatisés. Vous souhaitez que les résultats des tests automatisés remontent automatiquement dans Xray ? Vous êtes au bon endroit !

Avant de rentrer dans le vif du sujet, présentons rapidement l’outil Xray !

Xray est un plugin de test de Jira. Il permet de gérer la partie qualification d’un projet :

• Planification de campagnes de tests
• Création de cas de test avec possibilité de les lier à une User Story (exigence d’un produit)
• Exécution des tests
• Génération de rapports de tests

“Très bien ! Mais moi je veux suivre les résultats de mes tests automatisés via Xray !”, me direz-vous.

Eh bien, ça tombe bien ! Parce que c’est possible ! Et, cerise sur le gâteau, c’est justement l’objet de cet article !

A noter que Xray peut importer plusieurs types de format de résultats de tests. Ce tutoriel utilisera le framework TestNG. Si vous souhaitez utiliser un autre framework, la logique sera la même mais il faudra adapter les dépendances et la configuration du plugin maven-surefire en conséquence.

Ce tutoriel est un complément à la documentation technique de Xray (disponible ici)

Pré-requis

• Avoir un compte Jira avec le plugin Xray (logique mais je le précise quand même 😉)
• Avoir un compte git et savoir l’utiliser
• Avoir une instance Jenkins disponible et utilisable
• Avoir un test automatisé fonctionnel utilisant le framework TestNG et pouvant être exécuté par un système Linux (pour en savoir plus sur TestNG, c’est par ici)
• Gérer le développement des tests automatisés avec Maven (pour en savoir plus, c’est ici)
• Avoir le plugin maven-surefire présent dans le fichier pom.xml du projet de tests automatisés.

Pour information, l’IDE que j’utilise aujourd’hui pour créer ces tests automatisés est IntelliJ IDEA Community (disponible ici).

Nous pouvons maintenant attaquer les choses sérieuses !

Etapes de ce tutoriel

• Etape n°1 : Modifications du fichier pom.xml
• Etape n°2 : Modification du fichier testng.xml
• Etape n°3 : Ajout des annotations Xray dans les tests automatisés
• Etape n°4 : Configuration de Jenkins
• Etape n°5 : Configuration du fichier Jenkinsfile
• Etape n°6 : Lancement du job de Jenkins et vérification des résultats

Retrouvez toutes les étapes de ce tutoriel en vidéo et si vous préférez lire (et peut-être, avouez-le, utiliser la fonction copier-coller !), les étapes sont également détaillées ci-dessous !

Etape n°1 : Modifications du fichier pom.xml

Commençons par ouvrir le fichier “pom.xml” de notre projet :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>exoauto</groupId>
    <artifactId>webdriver_java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>7.0.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-support</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M5</version>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Afin de lui ajouter les dépendances nécessaires pour profiter de l’extension Xray de TestNG !

Qu’est ce que c’est que cette histoire “d’extension Xray” ?

C’est très simple, il s’agit de donner la possibilité à l’automaticien de test d’ajouter des annotations TestNG spécifiques à Xray. Cela permet de définir 3 types d’informations :

• requirement : permet d’associer le test automatisé à l’exigence (User Story) que l’on souhaite,
• test : permet d’associer le test automatisé à un test présent dans Xray,
• labels : permet d’associer une étiquette (label) au test.

Ainsi, lors de la remontée des résultats des tests dans Xray, les différentes associations seront effectuées automatiquement ! Elle est pas belle la vie ?

Petite précision, il n’est pas obligatoire de mettre les 3 paramètres. Par exemple, si vous ne souhaitez pas associer d’étiquette, vous n’êtes pas obligés d’utiliser l’attribut “labels”.

Voici notre “pom.xml” avec l’ajout des dépendances Xray-TestNG :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>exoauto</groupId>
    <artifactId>webdriver_java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>7.0.0</version>
            <scope>test</scope>
        </dependency>
<!--===========================AJOUT DEPENDANCE XRAY-TESTNG============================================================--> 
        <dependency>
            <groupId>com.xpandit.xray</groupId>
            <artifactId>xray-testng-extensions</artifactId>
            <version>1.1.0</version>
            <scope>test</scope>
        </dependency>
<!--===================================================================================================================-->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-support</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M5</version>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>
        </plugins>
    </build>
<!--===============================AJOUT REPOSITORY POUR XRAY=========================================-->
    <repositories>
        <repository>
            <id>xpandit</id>
            <name>xpand-releases</name>
            <url>http://maven.xpand-it.com/artifactory/releases</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>
<!--=================================================================================================-->
</project>

A la fin de ce fichier “pom.xml”, on peut constater l’ajout d’un “repository”. En effet, le “repository” par défaut est le “maven repository”, or ici la dépendance “com.xpandit.xray” ne se trouve pas dans le “maven repository” mais à l’url “http://maven.xpand-it.com/artifactory/releases« .

Configuration du plugin maven-surefire

Il faut maintenant configurer le plugin maven-surefire pour :

• spécifier que l’on souhaite utiliser le fichier “testng.xml” (cf. https://testng.org/doc/documentation-main.html#testng-xml ) pour lancer le ou les tests,
• prendre en compte les “attributes”, c’est à dire les paramètres requirement, test et labels lors de la génération du rapport des résultats (le fichier testng-results.xml)

Ce qui nous donne ceci :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>exoauto</groupId>
    <artifactId>webdriver_java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>7.0.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.xpandit.xray</groupId>
            <artifactId>xray-testng-extensions</artifactId>
            <version>1.1.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-support</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>3.141.59</version>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M5</version>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
<!--=============================== PARTIE AJOUTER DANS LA CONFIGURATION : =======================================================================================-->
                    <suiteXmlFiles>
                        <suiteXmlFile>testng.xml</suiteXmlFile>
                    </suiteXmlFiles>
                    <properties>
                        <property>
                            <name>reporter</name>
                            <value>org.testng.reporters.XMLReporter:generateTestResultAttributes=true,generateGroupsAttribute=true</value>
                        </property>
                    </properties>
<!--==============================================================================================================================================================-->
                </configuration>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>xpandit</id>
            <name>xpand-releases</name>
            <url>http://maven.xpand-it.com/artifactory/releases</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>
</project>

Etape n°2 : Modification du fichier testng.xml

Lors du lancement des tests, il faut spécifier à TestNG que l’on souhaite utiliser et prendre en compte des annotations spécifiques (dans notre cas les annotations Xray). Il faut donc ajouter le “listener” de Xray qui se nomme “XrayListener” dans le fichier “testng.xml”.

Fichier “testng.xml” avec ajout de la partie “<listeners>” :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite thread-count="1" name="Surefire suite" verbose="0">
    <listeners>
        <listener class-name="com.xpandit.testng.annotations.XrayListener"></listener>
    </listeners>
    <test thread-count="1" name="Surefire test" verbose="0">
        <classes>
            <class name="com.projet.istqb.BaseTests"/>
            <class name="com.projet.istqb.TestCpc"/>
        </classes>
    </test> <!-- Surefire test -->
</suite> <!-- Surefire suite -->

N.B : pour avoir une petite astuce de génération du fichier “testng.xml”, vous pourrez vous référer à la vidéo tuto que nous allons partager sur ce sujet 😉

Etape n°3 : Ajout des annotations Xray dans les tests automatisés

Maintenant, ouvrons le code source de notre test automatisé TestNG, qui pour le moment ne contient que des annotations classiques de ce framework…

package com.projet.istqb;

import org.testng.annotations.Test;
import pages.AnswPage;
import pages.IstqbPage;
import pages.MailboxPage;
import pages.ToolboxPage;

import static org.testng.Assert.assertEquals;

/* Classe TestCpc :
 * Navigateur cible : Google Chrome.
 * Cette classe représente le test "Cent pout Cent" qui consiste à vérifier que le mail reçu, de la part de
 * "contact@hightest.nc", contient bien la phrase : "Vous avez bien répondu à 20 question(s) sur 20, soit 100 %
 * de réussite. Félicitations, vous avez obtenu le score maximal !". Cette phrase est écrite uniquement en cas de
 * résussite à 100 %.
 */
public class TestCpc extends BaseTests{
    private String expResult = "Vous avez bien répondu à 20 question(s) sur 20, soit 100 % de réussite. Félicitations, vous avez obtenu le score maximal !";
    private String email = "neoanderson@yopmail.com";

    /* Méthode testSucessfulCpc :
     * Cette méthode permet d'exécuter le cas de test avec le scénario suivant :
     * Etape 1 - Cliquer sur "Toolbox"
     * Etape 2 - Cliquer sur le lien vers le quiz ISTQB Fondation en français
     * Etape 3 - Cliquer sur les bonnes réponses du test
     * Etape 4 - Cliquer sur le bouton "Terminer!"
     * Etape 6 - Entrer une adresse e-mail yopmail.com (ne pas cocher la case pour la newsletter)
     * Etape 7 - Cliquer sur "OK"
     * Etape 8 - Ouvrir la page "www.yopmail.com"
     * Etape 9 - Vérifier que le mail reçu de la part de "contact@hightest.nc" indique bien la phrase attendue :
     * "Vous avez bien répondu à 20 question(s) sur 20, soit 100 % de réussite. Félicitations, vous avez obtenu
     *  le score maximal !".
     */
    @Test
    public void testSucessfulCpc(){
        ToolboxPage toolboxPage = homePage.clickToolboxLink();
        IstqbPage istqbPage = toolboxPage.clickLinkByHref();
        AnswPage answPage = istqbPage.clickRadio();
        MailboxPage mailboxPage = answPage.emailResult(email);
        String result = mailboxPage.getResult();
        assertEquals(result,expResult);
    }
}

… et ajoutons maintenant l’annotation Xray avec les informations que l’on souhaite :

// ne pas oublier d'ajouter tout en haut de la page : 
// import com.xpandit.testng.annotations.Xray;

    @Test
    @Xray(requirement = "HTUTO-34", test="HTUTO-35")
    public void testSucessfulCpc(){
        ToolboxPage toolboxPage = homePage.clickToolboxLink();
        IstqbPage istqbPage = toolboxPage.clickLinkByHref();
        AnswPage answPage = istqbPage.clickRadio();
        MailboxPage mailboxPage = answPage.emailResult(email);
        String result = mailboxPage.getResult();
        assertEquals(result,expResult);
    }
}

Ici le test automatisé sera associé à l’exigence dont la clé (identifiant dans Xray) = HTUTO-34 et au test dont la clé = HTUTO-35. Attention : le test présent dans Xray avec la clé HTUTO-35 est un test de type “Generic” car on souhaite identifier ce test comme un test automatisé.

Bien ! Notre test est prêt à être exécuté ! Alors faisons-le avec la commande suivante :

mvn surefire:test

Un rapport est généré dans le dossier “surefire-report” et devrait se nommer “testng-results.xml”.

Ouvrez ce fichier, vous devriez voir à l’intérieur un nœud nommé “attributes”. Si ce n’est pas le cas, c’est qu’il y a une erreur de configuration quelque part ! Faites bien attention aux versions des dépendances que vous utilisez (par exemple, la version TestNG 7.1.0 n’a pas fonctionné avec mon projet) !

Exemple de fichier “testng-results.xml” :

Une fois que vous avez vérifié que votre fichier “testng-results.xml” est correctement généré, vous pouvez passer à la configuration de Jenkins pour l’intégration continue des résultats des tests dans Xray.

Etape n°4 : Configuration de Jenkins

Connectez-vous sur votre instance Jenkins, cliquez sur “Administrer Jenkins” puis sur “Gestion des plugins”.

Cliquez sur l’onglet “Disponibles” et recherchez “Xray”. Vous devriez avoir parmi vos résultats le plugin “Xray – Test Management for Jira Plugin”. Installez-le et redémarrez Jenkins !

Cliquez sur “Administrer Jenkins” puis sur “Configurer le système” ; vous devriez voir maintenant une partie intitulée “Xray Configuration”.

Comment remplir “Xray Configuration” ?

Il faut d’abord demander à votre administrateur Jira préféré la génération d’une clé API. Si vous êtes l’administrateur, bravo, vous pouvez générer la clé API sans rien demander à personne 🙂 !

La génération d’une clé devrait vous fournir les paramètres suivants : Client ID et Client Secret.

Ces 2 paramètres sont à enregistrer dans la partie “Credentials”. Il suffit de cliquer sur “ajouter” et d’insérer la donnée Client ID dans le champ “Username” (Nom utilisateur, pas “ID”) et Client Secret dans le champ “Password”.

Vous devriez obtenir une “Configuration ID” qui sera à insérer dans le script du pipeline (cf. fichier “Jenkinsfile” présenté un peu plus loin).

Exemple de configuration :

Créez un job de type pipeline avec le nom que vous souhaitez (si le type “pipeline” n’est pas disponible parmi vos items, c’est qu’il manque un ou plusieurs plugins dans votre instance Jenkins !).

Comment configurer mon pipeline ?

Voici un exemple de configuration du pipeline :

Partie “Général” :

La case “Supprimer les anciens builds” est cochée : cela permet de demander à Jenkins de conserver un nombre limité de builds (à configurer à l’aide du champ “Nombre maximum de builds à conserver”).

Partie “Build Triggers” :

La case “Construire périodiquement” est cochée : cela permet d’exécuter le script du pipeline à une fréquence déterminée (vous pouvez cliquer sur le point d’interrogation de “Planning” pour en savoir plus).

Partie “Pipeline” :

Dans le champ “Repository URL” : insérez l’URL de votre dépôt git.

Dans le champ “Credentials” : cliquez sur “Ajouter” puis enregistrer le login et le mot de passe de votre utilisateur git.

Dans le champ “Branch Specifier” : insérer la branche où se trouve votre “Jenkinsfile” (master par défaut).

Dans le champ “Script Path” : insérer le chemin où se trouve le script du pipeline (nommé “Jenkinsfile”) dans votre répertoire git (en général on met le “Jenkinsfile” à la racine du projet)

Il ne reste plus qu’à cliquer sur “Apply” puis “Sauver” !

Voilà, votre job Jenkins est prêt pour l’action !

Mais… il ne manque pas quelque chose ? (Là, c’est le moment où on voit si vous avez suivi !)

Effectivement, nous avons spécifié à Jenkins où se trouve le script du pipeline mais nous ne l’avons pas encore créé !

Alors allons-y !

Etape n°5 : Configuration du fichier Jenkinsfile

Par défaut, le script de configuration du pipeline se nomme “Jenkinsfile”. Ce script va servir à exécuter un test automatisé puis envoyer les résultats à Xray.

Script Pipeline : Jenkinsfile

pipeline {
    agent any

    tools {
        // Installation Maven selon le nom donné dans la configuration globale de Jenkins
        maven "Maven"
    }

    stages {
        stage('Pre Build'){
            steps{
                sh "chmod +x driver/chromedriver"
            }
        }
        stage('Build') {
            steps {
                // Exécuter Maven (version pour un système Unix)
                sh "mvn -Dmaven.test.failure.ignore=true clean"
                sh "mvn install"
            }
        stage('Import results to Xray') {
            steps {
                step([$class: 'XrayImportBuilder', endpointName: '/testng', importFilePath: 'target/surefire-reports/testng-results.xml', importToSameExecution: 'true', projectKey: 'HTUTO', serverInstance: 'fd45sd-dq7856-dsdd5656ytz'])
            }
        }
        }
    }
}

Description de la partie “stages” :

• “Pre Build” : sert à permettre l’exécution de “chromedriver” (version linux)
• “Build” : sert à effacer les résultats des tests précédents, compiler et exécuter le test automatisé, ici « TestCpc »
• “Import results to Xray” : sert à envoyer les résultats à Xray.

Etape n°6 : Lancement du job de Jenkins et vérification des résultats

Enfin ! Nous allons pouvoir constater le fruit de notre labeur 🙂 !

Il y a deux façons de faire : soit vous attendez que Jenkins lance un build automatiquement (puisque nous avons configuré un lancement périodique à l’étape n° 3), soit vous lancez le job manuellement en cliquant sur “lancer un Build”.

Une fois le Build lancé, cliquez sur “Console Output” du build en cours et vérifier qu’il n’y a pas eu d’échec d’exécution.

Ensuite, allez sur votre projet Xray pour vérifier que le résultat du test automatisé a bien été importé.

Exemple d’un résultat de test automatisé dans Xray :

Voilà ! Vous savez maintenant intégrer les résultats de vos tests automatisés de manière continue dans un projet Xray !

J’espère que ce tutoriel vous aura été utile 🙂 !

~ Jérôme Liron, ingénieur test applicatif chez Hightest

« L’automatisation des tests, ça coûte cher ! »

Voilà une idée reçue qui freine bon nombre de personnes au moment de mettre en place une démarche d’automatisation des tests.

Il est vrai que les écueils existent, mais certaines démarches permettent de limiter ces risques et de mettre en œuvre, rapidement, des projets d’automatisation couronnés de succès. Dans cet article, nous allons présenter un moyen simple et efficace de maîtriser ces coûts… voire d’obtenir un ROI immédiat.

Le DDT, qu’est-ce que c’est ?

DDT est l’appellation courte de dichlorodiphényltrichloroéthane, mais nous ne parlons pas aujourd’hui de chimie et nous n’allons pas non plus vous suggérer de pulvériser de l’insecticides sur les bugs… car c’est aussi l’acronyme du Data Driven Testing !

Pourquoi implémenter le Data Driven Testing ?

Cette pratique présente au moins 3 avantages.

• Le code est plus clair et plus concis. Finis les doublons, finies les données en dur !
• L’ensemble des parties prenantes peut consulter et modifier les données sans avoir à lire le code. Cela rend ainsi plus accessible le sujet d’automatisation des tests aux personnes qui ne savent pas ou ne souhaitent pas développer.
• Et surtout… Ça permet de gagner beaucoup de temps.

Dans quel contexte mettre en œuvre cette pratique ?

Dans notre article précédent, nous donnions des axes de réflexion pour choisir quels tests automatiser. L’un des axes consiste à déterminer quels tests sont les plus répétitititititi…tifs. Vous voyez l’idée : vous avez un unique formulaire, des centaines de manières différentes de le remplir, et une ribambelle de champs à vérifier en sortie. Réaliser ces tests des heures d’affilée peut relever du supplice intellectuel, et les déléguer à quelqu’un d’autre n’est pas beaucoup plus sympathique.

Dans ce contexte, le Data Driven Testing est tout particulièrement pertinent.

Génial ! Par quoi commencer ?

Quitte à faire une lapalissade, rappelons que le Data Driven Testing est… piloté par les données. Alors le mieux pour commencer, c’est de lister les jeux de données des tests que l’on va vouloir automatiser.

(Et si vous ne savez pas quels cas de test automatiser, nous vous suggérons de jeter un œil à cet article !)

Prenons un exemple simple : un cas de test dont l’objectif soit de vérifier qu’un champ de recherche fonctionne bien. Dans ce contexte, on peut créer un tableur, par exemple au format CSV, contenant ces 12 requêtes et leur résultat attendu.

Voici le contenu du fichier de jeux de données (qu’on appellera, pour la suite, requetes.csv) :

Ce fichier peut être rempli par les testeurs, les acteurs métiers, le PO, ou toute partie prenante souhaitant s’impliquer dans les tests. L’avantage du format tableur, c’est qu’il permet de collaborer en toute simplicité. On est bien loin de l’image intimidante d’une automatisation des tests « trop technique », inaccessible à la majorité de l’équipe projet !

Maintenant, à quoi ressemble le script ?

Nous avons listé 12 requêtes à vérifier dans le fichier dont on parlait précédemment. Il suffit maintenant de déclarer ce fichier comme source de données pour le test automatisé.

Voici un exemple sur JUnit 5, qui utilise l’annotation @ParameterizedTest :

@CsvFileSource(files = "src/test/resources/requetes.csv")
@ParameterizedTest
public void recherche_simple(String requete, int nb_resultats_attendus){
    lancerRecherche(requete);
    verifierNbResultatsAttendus(nb_resultats_attendus);
}

12 tests en un… c’est merveilleux, non ? 🙂

10, 100, 1000 cas de test… quelle est la limite ?

L’enfer est pavé de bonnes intentions

Vous l’aurez compris, avec le DDT, le coût de développement sera le même pour 10, 100 ou 1000 jeux de données. Dans cette mesure, il peut être séduisant de lancer l’automate sur le plus de cas possible.

Nous avons développé le test en 1 heure, il va jouer 1000 tests qui durent chacun 1 minute, nous aurons donc forcément atteint notre ROI au bout de la première exécution du 61^ème test ! C’est vertigineux !

Halte là ! Une belle peau de banane vient de se mettre dans votre chemin : l’envie (consciente ou non) de prouver le ROI à tout prix.

Dans l’exemple précédent, nous vérifions que la requête « Sandrawa Geffroidwa » ne remonte aucun résultat. Il serait possible, au même coût de développement, de vérifier aussi que « Sandrawo Geffroidwo » produit le même résultat, et ainsi de suite avec n’importe quel suffixe.

De même, on pourrait imaginer un test de création d’utilisateur avec comme pseudo « Julie », et un autre identique, avec cette fois un pseudo différent, « Marie ». Pourquoi pas… mais pourquoi ? Les 2 pseudos tiennent sur 5 caractères ASCII, quel intérêt cela apporte-t-il de tester ces deux cas ?

Rien ne sert de gonfler artificiellement le nombre de jeux de données, même si cela donne l’impression d’atteindre plus vite le ROI.

Les risques à avoir en tête

Certains paramètres doivent en effet être pris en compte en-dehors du coût de développement :

• Le test va mettre un certain temps à s’exécuter. Peut-être quelques secondes… mais une flopée de tests inutiles peut faire perdre à la longue de précieuses minutes voire de longues heures !
• Le test va produire des résultats que des personnes vont analyser, surtout si le test est en erreur. Or, dans cet exemple, les deux tests produiront (très très certainement) le même résultat. Il n’est pas question de faire perdre de temps d’analyse sur ce type de tests en doublon.
• Comme les résultats seront identiques, le rapport global des tests sera biaisé.
• Le test va vivre et devra être maintenu… peut-être par une autre personne que vous. Cette personne va devoir se plonger dans les jeux de données afin de savoir pour quelle raison ils ont été conçus comme tels, et se demandera pourquoi tant de tests se ressemblent.

Bref, avec ou sans DDT, l’automatisation des tests reste en grande partie une pratique d’optimisation du temps de cerveau humain, et il ne faut pas perdre de vue cet aspect !

Solution simple

Nous préconisons donc de donner un nom à chacun des jeux de données, afin que quiconque soit en mesure de comprendre son sens et son utilité. Et si vous vous apprêtez à créer un jeu de données à faible valeur ajoutée, vous vous en rendrez compte d’autant mieux.

Votre tableur ressemblera donc plutôt à cela :

Et voilà, la peau de banane est écartée !

Quels outils permettent de faire du DDT ?

Cette approche est tellement efficace que rares sont les outils d’automatisation des tests qui ne permettent pas de la mettre en œuvre. De notre côté, nous l’utilisons aussi bien sur nos projets Selenium (avec JUnit 5), UFT, Protractor, Postman…

Si vous voulez un tutoriel pour mettre en oeuvre le Data Driven Testing avec JUnit 5, nous vous conseillons cette vidéo présente sur Test Automation University.

Le Data Driven  Testing est une pratique incontournable : l’essayer, c’est l’adopter.

Et vous, utilisez-vous le Data Driven Testing ?

Dans notre dernier article, nous abordions l’un des aspects non-fonctionnels de la qualité les plus critiques en ce contexte d’explosion du choix des devices : la portabilité. Saviez-vous que des sociétés aussi inattendues que Land Rover (oui, le constructeur de 4×4 !) proposaient des smartphones ? Il est désormais virtuellement impossible de tester toutes les configurations existantes.

Ce phénomène est désigné sous le terme de fragmentation. Mais il ne concerne pas seulement les devices ; il touche aussi les systèmes d’exploitation (OS), la diversité des navigateurs web, ainsi que les différentes moutures et version de chacun des éléments cités.

Techniques de test de portabilité

Dans ce contexte, les équipes de test ne baissent pas les bras, car il existe de nombreuses solutions pour répondre à cette problématique.

La plus classique : posséder sur site des moyens de tester telle ou telle configuration. Ça peut être un tiroir rempli de téléphones de test (qui à la longue pourrait plutôt tenir lieu de musée du rétrophoning). Certaines entreprises conservent également des machines avec des OS anciens, comme Windows 7 ou Vista, avec de vieilles versions d’Internet Explorer.

Si l’on veut s’affranchir de ces contraintes et augmenter le nombre de configurations testables, il existe des fermes de devices qui permettent de tester sur des environnements réels tout en n’ayant pas à les acquérir chez soi. pCloudy fait partie de ces services, de même que BrowserStack dont nous allons parler ensuite.

Des émulateurs permettent, quoi qu’il en soit, d’avoir un premier niveau d’information. Si on arrive à reproduire un bug vu en production sur un émulateur, il n’y a pas forcément besoin de pousser le test plus loin pour pouvoir commencer à corriger le bug.

Enfin, pour les besoins croisés de tests de portabilité et d’utilisabilité, le crowdtesting est une stratégie tout indiquée.

Situation

Vous avez besoin de reproduire rapidement un bug sur un navigateur particulier ?

Vous souhaitez avoir un aperçu rapide d’un site web sur un grand panel de navigateurs ?

Dans ces situations, ce qui suit vous intéressera !

Tester rapidement et gratuitement un navigateur

BrowserStack est, si on traduit mot à mot, un « tas de navigateurs », mais cette simple traduction est trompeuse, car il est aussi possible d’interagir directement avec des téléphones réels. Tout comme pCloudy, BrowserStack propose une formule gratuite et des formules payantes. Ce qu’il est intéressant de noter, c’est que si la version gratuite de pCloudy propose un choix de devices restreint, celle de BrowserStack suit une stratégie différente : c’est le temps de chaque session qui est limité !

Si votre scénario prend une minute ou moins, rendez-vous sur BrowserStack et vous serez en mesure de profiter du service d’un grand nombre de navigateurs.

Rendez-vous sur la page d’accueil de BrowserStack, cliquez sur « Free trial », et choisissez votre environnement !

Une minute, c’est peut-être un peu court pour tester chacune des fonctionnalités offertes, en revanche elles sont bien là, même en version gratuite :

Par exemple, le rapport de défaut sur Slack permet d’envoyer en un clic les informations essentielles :

Et voilà, vous êtes maintenant en mesure d’exécuter rapidement et simplement des tests sur un grand nombre de navigateurs, et ce gratuitement.

Et si vous souhaitez un jour passer en version payante, les prix sont tout à fait raisonnables pour le service rendu. Il existe en outre un tarif réduit pour les freelances et, cerise sur le gâteau, une gratuité les projets open source !

Quoi qu’il en soit, bons tests à vous !

Qu’est-ce que pCloudy ?

pCloudy est une plateforme qui donne accès des machines (physiques ou virtuelles) situées en Inde ou aux Etats-Unis, et avec lesquelles il est possible d’interagir. Un grand nombre de smartphones et de tablettes sont proposées, de multiples constructeurs différents et avec une large gamme de versions d’Android et d’iOS. Des navigateurs sont également disponibles.

Ce type de service est parfois désigné sous l’expression de ferme de devices.

A quoi sert ça sert ?

La plateforme pCloudy permet de récolter de précieuses informations sur la portabilité des applicatifs. Parfois négligés, les tests de portabilité sont pourtant essentiels ; ils permettent de comprendre comment les utilisateurs finaux verront l’interface. Pourront-ils interagir correctement avec cette interface, quel que soit leur navigateur, leur système d’exploitation et la version de ce dernier ? Les éléments d’affichage seront-ils harmonieusement répartis, quelle que soit la taille de leur écran ? Est-on vraiment responsive ? Au même titre que les autres tests non-fonctionnels, cet aspect passe malheureusement souvent au second plan, faute de temps, de moyens et souvent, de sensibilisation.

On a déjà des téléphones de test, est-ce utile de tester aussi sur pCloudy ?

Ha, les fameux téléphones de test… Les développeurs et les testeurs se chamaillent pour les avoir, on ne sait jamais qui a emprunté le Google Pixel 2, on cherche partout ce fichu câble (« non pas celui-là, l’USB C tu sais ») et on doit gentiment attendre son tour pendant que Boniface monopolise l’unique iPhone de l’équipe (« Attends encore deux minutes s’il te plaît. Enfin, deux autres minutes… »).

Autre problème : la couverture. Vous avez 10 téléphones de test ? Bravo, c’est davantage que beaucoup d’équipes projet. Mais combien de téléphones différents ont vos utilisateurs ? C’est un autre ordre de grandeur. Effectuer des sanity checks sur un grand nombre de machines vous donnera une confiance bien plus solide dans la qualité de votre applicatif.

Enfin, dernier problème : la reproductibilité. Un utilisateur de prod se plaint de ne pas pouvoir réaliser telle ou telle action, vous avez besoin de reproduire « son » bug pour comprendre de quoi il en retourne. Sur un de nos derniers projets, il y avait un bug majeur que l’on pouvait reproduire sur OnePlus 7, mais pas sur OnePlus 6, avec la même version d’Android ! Il est donc bien pratique d’avoir un pool important de machines pour maximiser ses chances de reproduire des bugs marginaux.

En conclusion : qui peut le plus peut le moins ; pas besoin de jeter au compost vos téléphones de test, en revanche pCloudy pourrait vous apporter un coup de boost considérable.

Comment ça marche ?

Voici un petit aperçu de l’usage le plus basique que l’on peut avoir de pCloudy : le test « manuel » d’applications mobiles.

Premièrement, dans l’onglet « My app / data », téléverser un fichier APK ou IPA.

Puis, dans l’onglet « Devices », choisir un téléphone ou une tablette.

Après quelque secondes, on se retrouve face à l’écran du téléphone et on peut librement interagir avec.

Libre à nous alors d’installer une application, de changer les paramètres du téléphone, de retourner l’écran… et de réaliser tous les tests souhaités !

Combien de machines sont mises à disposition ?

Sur la liste des devices, en février 2021, s’affichaient 267 devices physiques. Selon nos calculs, cela représente bien 40 kilos de smartphones et tablettes ; qui dit mieux ?

Est-il possible d’utiliser pCloudy dans une démarche d’automatisation des tests mobiles ?

Oui. pCloudy s’interface avec plusieurs solution d’automatisation des tests mobiles : Appium, Espresso, Opkey, Calabash et XCTest.

Combien ça coûte ?

Une quinzaine de devices peuvent être librement utilisés sans abonnement payant. Pour pouvoir accéder à l’ensemble des devices proposés, un abonnement doit être acheté, au mois ou à l’année (voir le détail des prix).

Le support est-il réactif ?

Oui : un chat est proposé au sein du site et le support pCloudy répond dans la minute. C’est en tous cas ce que nous avons pu constater dans notre timezone particulière ; une confirmation métropolitaine serait la bienvenue !

Une astuce à donner ?

Oui, 2 pour le prix d’une !

Gestion d’une erreur commune

Lorsque vous tentez d’installer une application iOs (donc contenue dans un fichier IPA), il peut arriver que vous tombiez sur l’erreur « A valid provisionning profile for this executable was not found. » A ce moment-là, pour régler le problème, se rendre dans l’onglet « My app / data » et cliquer sur l’option « Re-sign » associée au fichier IPA.

La documentation pCloudy donne davantage d’informations sur ce comportement.

Attention aux Apple Id

Si vous saisissez votre Apple Id, pensez bien à vous déconnecter à la fin de votre session.

______________________________

Si vous souhaitez découvrir un autre service de tests de portabilité, vous pouvez aussi vous pencher sur BrowserStack.

Et vous, utilisez-vous une ferme de devices ? Qu’est-ce que cela vous apporte ? La section des commentaires est à vous. A bientôt !

Pourquoi passer la certification A4Q Selenium ?

Les certifications sont un sujet clivant. Certaines personnes en raffolent, d’autres considèrent cela d’un œil méfiant, tandis que rôdent les spectres du bachotage et du bourrage de CV. De notre côté, nous voyons cela comme une bonne manière de confirmer des acquis. Nous avons tendance à passer une certification après plusieurs années de pratique, plutôt que de démarrer from scratch par une formation intense et de passer l’examen dans la foulée, avant que les connaissances ne soient bien ancrées dans notre esprit. C’est dans cette optique que nous avons envisagé de passer la certification A4Q Selenium Tester Foundation.

Comme le contenu du syllabus est intéressant, le lire ne peut être que profitable et vous aidera à prendre du recul ; à vous de juger ensuite si passer la certification peut apporter à votre carrière.

A qui s’adresse cette certification ?

Le syllabus ne précise pas le public visé. Nous considérons que la certification serait profitable aussi bien aux QA en charge de l’automatisation des tests, qu’aux test managers ayant besoin d’avoir une vue d’ensemble sur les bonnes pratiques d’automatisation des tests.

Que contient le syllabus A4Q ?

Autant l’annoncer d’emblée : le contenu du syllabus est excellent. En plus des éléments techniques auxquels on s’attend, il contient également de très bonnes connaissances de fond (philosophie de l’automatisation des tests, facteurs de réussite, sensibilisation aux biais qui entourent cette discipline). De précieux conseils pour partir sur de bonnes bases !

Le syllabus A4Q apprend-il à mettre en place un projet Selenium ?

Oui et non, mais pour préciser les choses simplement, le syllabus n’est pas un tutoriel ! Si vous souhaitez apprendre Selenium, mieux vaut vous tourner vers des sites tels que Test Automation University. Le syllabus vous permettra d’ancrer tout ce que vous aurez appris, et vous apprendra peut-être aussi de nouvelles fonctions que vous ne connaissiez pas.

Quel « parfum » de Selenium est enseigné ?

Selenium dispose de connecteurs avec une dizaine de langages ; dans ce syllabus, c’est Python qui est utilisé.

Si vous avez l’habitude d’un autre langage, pas de panique, la transition est plutôt douce.

En vrai… la certification Selenium est-elle difficile à obtenir ?

Maîtriser le syllabus doit être votre priorité ; avoir de l’expérience sur l’implémentation de tests Selenium vous aidera aussi évidemment.

40 questions sont posées lors de l’examen, qui dure une heure, ce qui laisse quand même du temps pour réfléchir (c’est deux fois moins de questions que pour la certification PSPO et PSM par exemple !)

Le seuil de réussite est de 65 %, comme pour ISTQB Fondation. Toujours à titre de comparaison, PSPO et PSM exigent 85 % de réussite.

Peut-on passer la certification A4Q à distance ?

Oui. Préparez-vous à une surveillance assez stricte pendant l’examen : quelqu’un devra garder un œil sur vous via la webcam de votre ordinateur et via la caméra de votre appareil photo ; il vous faudra aussi montrer la pièce où vous passerez l’examen sous toutes les coutures (c’est le moment de mettre un peu d’ordre dans votre maison…) Attention aussi, un débit internet minimum est requis, il faudra vous assurer de disposer d’une excellente connexion pour éviter les pépins.

Peut-on passer la certification A4Q en candidat libre, sans formation préalable ?

Le syllabus est trompeur sur cette question :

« Les examens ne peuvent être passés qu’après avoir suivi la formation A4Q Testeur Selenium au niveau fondation, puisque l’évaluation par l’instructeur de la compétence du candidat dans les exercices fait partie de l’obtention de la certification. »

Malgré cette mention, il est tout à fait possible de passer la certification en candidat libre, sans avoir passé de formation au préalable.

Peut-on passer la certification A4Q Selenium en français ?

Bonne nouvelle pour les personnes qui redoutent les examens en anglais : il est possible de passer la certification A4Q en français.

Prenez tout de même quelque chose en compte : si vous choisissez de passer l’examen en anglais et que ce n’est pas votre langue maternelle, vous pourrez disposer de 15 minutes supplémentaires.

Cette certification est-elle valide à vie ?

Nous n’avons en tous cas pas trouvé de mention contraire.

Où peut-on s’entraîner en passant un test blanc A4Q Selenium ?

Un quiz en ligne A4Q Selenium est présent depuis peu sur notre site. Voici le lien vers le test blanc. Bon courage !

Quelques punchlines pour donner envie ?

Avec plaisir car on aime les punchlines ! En voici quelques unes :

L’importance d’une stratégie d’automatisation

« Une organisation n’a jamais construit par hasard un projet d’automatisation réussi. » Syllabus, partie 1.1

« Tous les tests manuels ne devraient pas être automatisés. Parce qu’un script automatisé nécessite plus d’analyse, plus de conception, plus d’ingénierie et plus de maintenance qu’un script manuel, nous devons calculer le coût de sa création. » Syllabus, partie 1.2

Chaque projet d’automatisation est différent

« Tous les avantages ne peuvent pas être obtenus dans tous les projets, et tous les inconvénients ne se produisent pas dans tous les projets. » Syllabus, partie 1.1

Cela rejoint le 6^ème des 7 principes généraux du test logiciel : les tests dépendent du contexte.

L’origine de la plupart des bugs

« Les êtres humains trouvent la plupart des bogues ; l’automatisation ne peut trouver que ce qu’elle est programmée pour trouver et est limitée par le paradoxe des pesticides. » Syllabus, partie 1.1

N’est-ce pas libérateur à lire ? Comme vous le voyez, le syllabus s’attache rigoureusement à détruire les fausses attentes attachées à l’automatisation des tests.

L’arbre qui cache la forêt

« Les organisations sont souvent tellement préoccupées par les tests via l’interface graphique qu’elles oublient que la pyramide des tests suggère que davantage de tests unitaires/composants soient effectués. » Syllabus, partie 1.4

Si vous souhaitez expliquer l’importance de ces tests aux décideurs de votre organisation, ce jeu de sensibilisation aux tests unitaires pourrait vous être utile !

L’importance des logs et des acteurs qui en ont besoin

« Il est primordial qu’un automaticien de tests soit attentif à la précision des logs. Une bonne gestion des logs peut faire la différence entre un projet d’automatisation qui échoue et un projet qui réussit à apporter de la valeur lorsqu’elle est réalisée. » Syllabus, partie 3.1

Nous approuvons fortement cette remarque et vous proposons d’aller plus loin avec cet article, qui propose un moyen d’écrire des logs en langage naturel. Le syllabus met aussi l’accent sur les personnes qui vont avoir besoin de logs et de rapports de qualité :

« Il est important que les automaticiens de test déterminent qui veut ou a besoin de rapports d’exécution des tests, et quelles informations les intéressent. » Syllabus, partie 3.1

Nous espérons que ces éléments vous auront été utiles et que vous vous faites désormais une idée plus précise de la certification A4Q. Bonne révisions si vous envisagez de la passer, et bonne lecture du syllabus dans tous les cas !

Vous avez un test fonctionnel automatisé en Java (Selenium ou autre), et vous souhaiteriez enregistrer dans un fichier CSV la durée de chacune de ses étapes. Cela peut être en effet très utile pour surveiller l’évolution des performances de l’applicatif à tester !

Pour comprendre à quoi cela pourrait nous servir, voici un cas d’usage.

Cas d’usage

Lundi, on lance le test automatisé chronométré. Le parcours d’inscription dure environ 40 secondes ; les durées de toutes les étapes sont enregistrées dans un rapport au format CSV. Le lendemain, un refacto du back a lieu. On relance le test, cette fois l’inscription dure 45 secondes. On observe le rapport CSV. On identifie l’étape où ça coince pour se concentrer dessus. On voit que le temps de réponse d’une API a augmenté de 7 secondes (mince !), et qu’un autre temps a diminué de 2 secondes (chouette !) Un correctif est livré, on relance le test. Le parcours dure maintenant 38 secondes. Ces résultats sont communiqués et l’équipe est congratulée. Tout est bien qui finit bien !

Qu’est-ce que ça change par rapport à d’habitude ?

On documente mieux les mauvaises nouvelles

« C’est plus lent qu’avant. » Voilà une phrase que tout le monde souhaite prendre au sérieux. Le problème est qu’elle est fort imprécise. Plus lent comment ? Il faut se baser sur les souvenirs d’une personne. Si elle est du genre à forcer le trait, on peut entrer dans de bien épineuses discussions. Et si on est plusieurs à s’y mettre… « Moi ça a toujours été lent, est-ce que c’est à cause de ma machine ? » Etc. Bref, on cherche à éviter au maximum ce genre d’inutiles échanges. D’autant que tout ça nous rappelle à quel point les exigences non-fonctionnelles ont été mises de côté, comme trop souvent…

Avec ce type de rapport, il va devenir très simple de porter un regard objectif sur la performance des applicatifs.

… mais aussi les bonnes !

Au détour d’une refonte, vous constaterez peut-être que certaines étapes durent moins longtemps qu’avant. Ce sera désormais plus simple de le prouver. Eh oui, en tant que QA, on peut aussi aussi remonter des effets de bord positifs ! Cela permet de donner le sourire à l’équipe et surtout de pouvoir capitaliser dessus.

Objection votre honneur !

« Ah oui certes, mais pourquoi ne pas utiliser un outil dédié à ce type de test, par exemple Gatling ? »

Loin de nous l’envie de réinventer la roue ! La solution que nous allons proposer a pour objectif de :

• S’intégrer à des tests existants en un rien de temps
• Répondre à un besoin d’enregistrement des performances très simplement
• Fournir un rapport frugal mais très clair
• S’intégrer à un parcours utilisateur en passant par le front

Nous vous invitons néanmoins à garder un point à l’esprit. La durée des étapes ne dépend pas seulement des performances de l’applicatif (et autres facteurs tels que son environnement technique, la connexion internet, etc.) ; elle dépend aussi de la vitesse d’exécution du webdriver, qui dépend en bonne partie de votre script lui-même !

Si jamais vous changez votre script de test, toutes vos métriques passées peuvent devenir obsolètes. Il est donc important de stabiliser vos tests, notamment en optimisant les temps d’attente des éléments de la page web, avant de vous lancer dans cette démarche.

Balance le code !

Ok, ok, le voici ! Copiez-collez-le sauvagement si ça vous chante. Et si vous voulez plus d’explications, rendez-vous après ce gros bloc de Java.

Le gros bloc de code que vous attendiez

import org.junit.Test;
import java.io.*;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

public class PerfTest {

    ArrayList<BaliseTemporelle> balisesTemporelles = new ArrayList<>();

    @Test
    public void exemplePourMontrer() throws InterruptedException {
        String nomScenario = "Création de compte";
        BaliseTemporelle init = new BaliseTemporelle("Initialisation de la première durée"); // Cette première balise temporelle n'apparaîtra pas dans le fichier.
        balisesTemporelles.add(init);
        Thread.sleep(2000); // Ici, mettre lesdites étapes de test. Pour une meilleure lisibilité, nous ne mettons que des temps de pause, qu'on pourra retrouver dans le fichier de rapport.
        BaliseTemporelle accesSite = new BaliseTemporelle("Ouverture du navigateur et accès à telle URL");
        balisesTemporelles.add(accesSite); // On ajoute l'étape une fois qu'elle est terminée
        Thread.sleep(4000);
        BaliseTemporelle affichageFormulaireInscription = new BaliseTemporelle("Affichage du formulaire d'inscription");
        balisesTemporelles.add(affichageFormulaireInscription);
        Thread.sleep(6000);
        BaliseTemporelle remplissageFormulaireInscription = new BaliseTemporelle("Remplissage");
        balisesTemporelles.add(remplissageFormulaireInscription);
        Thread.sleep(8000);
        BaliseTemporelle validationFormulaireInscription = new BaliseTemporelle("Validation du formulaire d'inscription");
        balisesTemporelles.add(validationFormulaireInscription);
        enregistrerDurees(nomScenario);
    }

    // Ce qui suit est un ensemble de fonctions que vous devrez, de préférence, ranger ailleurs.

    private class BaliseTemporelle {
        String nom;
        Timestamp timestamp;

        public BaliseTemporelle(String nom){
            this.nom = nom;
            timestamp = new Timestamp(System.currentTimeMillis());
        }

        public Timestamp getTimestamp(){
            return timestamp;
        }

        public String getNom(){
            return nom;
        }
    }

    private ArrayList<Long> getDureesEtapes(){
        Timestamp premier = balisesTemporelles.get(0).getTimestamp();
        ArrayList<Long> durees = new ArrayList<>();
        for (BaliseTemporelle baliseTemporelle : balisesTemporelles) {
            Timestamp deuxieme = baliseTemporelle.getTimestamp();
            if (premier != deuxieme) {
                long diffTimeSecondes = (deuxieme.getTime() - premier.getTime()) / 1000;
                durees.add(diffTimeSecondes);
                premier = deuxieme;
            }
        }
        return durees;
    }

    public void enregistrerDurees(String nomScenario) {
        ArrayList<Long> durees = getDureesEtapes();
        StringBuilder sbDurees = new StringBuilder();
        Long total = new Long(0);
        for (Long duree : durees) {
            total += duree;
            sbDurees.append(duree);
            sbDurees.append(";");
        }

        try {
            File file = new File("src\test\java\utils\" + nomScenario  + ".csv"); // A remplacer par le chemin de votre choix...
            boolean creerFichier = file.createNewFile();
            BufferedReader br = new BufferedReader(new FileReader(file));
            FileWriter fw = new FileWriter(file.getAbsolutePath(), true);
            BufferedWriter bw = new BufferedWriter(fw);
            if(creerFichier){
                StringBuilder sbNomEtapes = new StringBuilder();
                balisesTemporelles.remove(0); // On n'a pas besoin d'afficher le nom de la première étape vu que ce sont les durées qu'on affiche (diff entre étape n et étape n-1.
                for (BaliseTemporelle etape : balisesTemporelles) {
                    sbNomEtapes.append(etape.getNom());
                    sbNomEtapes.append(";");
                }
                bw.write("Date;" + sbNomEtapes.toString() + "Totaln");
            }
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd-hh-mm-ss");
            String date = sdf.format(new Date());
            bw.write(date + ";" + sbDurees.toString() + total + "n");
            br.close();
            bw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

Hé bien, c’était un gros bloc ! Mais rassurez-vous, c’est tout ce dont vous aurez besoin !

Quelques explications

Ce petit « cas de test » (vous l’aurez compris en lisant le code, il ne teste rien) va alimenter, à chaque exécution, un fichier nommé « Création de compte.csv ». Le nom de ce fichier dépend de la variable nomScenario.

Le contenu de ce fichier, ouvert dans Excel, ressemble à ça après deux lancements du test :

La durée qui s’affiche dans chacune des cellules est calculée en soustrayant l’horodatage d’une balise temporelle de la balise suivante (dans la fonction « enregistrerDurees »). Le nom de la première balise temporelle (voir la classe BaliseTemporelle) n’apparaît pas dans le tableau, car elle correspond au temps 0 du test.

Pas besoin de créer le fichier Excel à l’avance, le script gère tout seul la création et la modification. Assurez-vous simplement de supprimer le fichier Excel dès que vous souhaitez changer votre script, car les durées ne seront plus bonnes, et les noms des balises temporelles ne correspondront peut-être plus à celles d’avant. Vérifiez bien aussi que le chemin indiqué lors de l’initialisation de la variable « File » est valide, ou changez-le carrément.

C’est tout ce qu’il vous faut ! Bon chronométrage et n’hésitez pas à poser vos questions si vous en avez !

Développé depuis 2011 par Henix, une ESN française spécialisée dans la qualité logicielle, Squash TM est un outil de gestion des tests, ou test management, gratuit et open source. Très pratique, il permet à la fois de concevoir les tests, de les exécuter et de communiquer leurs résultats. Si vous souhaitez structurer ces activités et jeter à la poubelle vos antiques fichiers Excel, Squash TM est une solution intéressante à envisager !

Squash TM s’intègre dans une suite de logiciels conçus pour interagir ensemble, et qui constitue une véritable boîte à outils pour aider les testeurs dans leurs activités. Cette suite peut s’adapter à tout contexte métier ou technique, et peut accompagner la pratique de tests tant fonctionnels que non-fonctionnels. Dans cette suite, on compte également Squash TA (pour Test Automation) ou encore Squash CLI (pour Command Line Interface).

Nous utilisons Squash TM au quotidien auprès d’un grand nombre d’organisations qui l’ont intégré dans leur système d’information.

Cependant, même si cet outil est plutôt user-friendly, nous avons constaté qu’il n’était pas toujours utilisé à la hauteur de son potentiel. Voici donc aujourd’hui quelques astuces que nous avons adoptées au fil du temps et qui nous permettent d’augmenter drastiquement la performance des tests !

EDIT du 09/03/2022 : les captures d’écran visibles dans cet article ne reflètent pas la nouvelle interface de Squash TM. Toutefois, les astuces restent d’actualité ! Bonne lecture !

Astuce #1 : Les copier-coller, tu éviteras

Ça, c’est une méta-règle, à retenir avant toute chose. 

En programmation, le principe DRY (“Don’t Repeat Yourself”, en français “Ne vous répétez pas”) est un principe de développement logiciel qui consiste à éviter tout doublon dans un projet et ainsi améliorer le code, la lisibilité, la maintenance et le changement de celui-ci.

Eh bien, il est important aussi de l’appliquer aussi en gestion des tests afin de faciliter la maintenance du patrimoine de tests ! 

Les bonnes pratiques qui suivent vous aideront à respecter ce principe.

Astuce #2 : Des jeux de données, tu utiliseras

Pour éviter les redites, le moyen le plus efficace est d’utiliser la fonctionnalité des jeux de données de Squash TM. Trop de personnes passent à côté de cette jolie fonctionnalité qui pourtant est tellement efficace !

Des cas de test sans jeux de données

Imaginons une entreprise qui classe ses clients dans des segments aux noms poétiques. En fonction de son segment, chaque client a une page d’accueil personnalisée. Voici à quoi ressembleraient des tests rédigés sans utiliser la fonctionnalité des jeux de données :

On répète le nom de chaque segment 3 fois : dans le titre, dans l’action et dans le résultat attendu. Et les textes de l’action et du résultat attendu sont répété 6 fois, car il y a 6 segments. Super redondant ! Et maintenant, regroupons tout cela en un petit paquet bien rangé.

Un cas de test, plusieurs jeux de données

Vous voyez la syntaxe dollar/accolades ? Quand vous l’utilisez, l’onglet « Paramètres » du cas de test ajoute automatiquement le paramètre renseigné (ici, « segment »). Voyons à quoi ça ressemble, une fois qu’on a renseigné quelques valeurs possibles pour le paramètre « segment » :

Quand on ajoute dans une campagne ce cas de test comprenant 6 jeux de données, 6 « lignes » sont alors créées.

Attention à une chose toutefois : logiquement, vos 6 jeux de données auront tous la même importance (la métadonnée associée au cas de test lui-même). Si vous avez des degrés d’importance différents, il vaut mieux avoir autant de cas de test. Par exemple, si « Grenat » est un segment qui n’est plus utilisé que par une poignée de clients, qui représentent ceux qui sont en retard de paiement depuis plus de deux ans… on peut certainement considérer que l’importance du test est moindre.

Astuce #3 : Tes jeux de données, clairement tu nommeras

Quand vous créez un jeu de données, vous devez lui ajouter un titre, qui s’affichera dans la colonne « Jeux de données » (voir copie d’écran ci-dessus). Ne négligez pas cette étape. Au fil du temps en effet, vous n’aurez sans doute plus besoin d’exécuter vos cas de test en ouvrant la popup d’exécution et en lisant attentivement chacune des étapes. Il vous suffira de lire le nom de vos cas de test et celui de vos jeux de données. C’est pour cas que vous devez bannir les titres cryptiques tels que « JDD1 » et nommer vos jeux de données le plus précisément possible.

Astuce #4 : Tes cas de test, clairement tu nommeras aussi

Le nom d’un cas de test doit être descriptif et transmettre les informations nécessaires pour savoir ce qui est réellement testé. Il doit également être concis, afin d’être facile à comprendre. L’écriture d’un mauvais nom de scénario de test peut vous nuire de plusieurs façons :

• Il peut réduire la qualité de l’exécution des tests, car les testeurs ne comprennent pas correctement l’enjeu et testent finalement autre chose
• Il peut ralentir l’exécution des tests, car les testeurs ont besoin de se concentrer davantage pour comprendre la finalité du test
• Il peut rendre plus difficile la maintenance du référentiel de tests, pour les mêmes raisons.

Voici quelques exemples de mauvais noms de cas de test :

• Page de connexion
• Mail de relance
• Liste des utilisateurs
• Graphique de suivi

Pourquoi ce sont de « mauvais noms » ? Parce qu’ils parlent de fonctionnalités, mais pas de comportements attendus. Un cas de test est un scénario que l’on exécute en attendant un résultat, et le nom du cas de test doit donner une idée de ce résultat attendu… Ce faisant, cela permet de comprendre rapidement l’importance et l’enjeu de ce cas de test.

En effet, un test nommé « Page de connexion » peut recouvrir des enjeux très importants ou tout à fait mineurs. Voici, pour la liste précédente, quelques exemples de reformulation pour des cas de test d’importance très haute !

• Affichage de la page de connexion par défaut lorsque l’utilisateur n’est pas connecté

• Réception du mail de relance suite à une relance en masse
• Affichage de tous les utilisateurs au sein d’une liste
• Cohérence du graphique de suivi dans le temps

Et maintenant, voici quelques exemples de cas de test d’importance faible :

• Présence d’un tooltip au survol du champ « Enregistrer le mot de passe » sur la page de connexion

• Changement de couleur au survol du bouton de connexion présent dans le mail de relance
• Possibilité de saisir manuellement le nombre d’éléments affichés par page dans la liste des utilisateurs
• Conformité du code couleur du graphique de suivi

Le nom de certains cas de test vous semble un peu longuet ? C’est possible ! Mais c’est toujours plus pratique que d’avoir à ouvrir le cas de test et de fouiner dans ses étapes. Un exemple ci-dessous !

Astuce #5 : Tes cas de test, brièvement tu écriras

A l’inverse du nom du cas de test…

La meilleure façon d’écrire vos scénarios de test est d’avoir des étapes fort brièvement décrites, et d’aller à l’essentiel. Restez concis.

Cela vous aidera à aller droit au but, ce qui vous permettra de détecter plus facilement les anomalies.

Bousillons calmement une idée reçue

Vous l’avez sûrement déjà lu des milliers de fois : les cas de test sont une forme de documentation. Pour autant, ils ne visent pas :

• à décrire de manière exhaustive tout ce qui est attendu de l’application
• à se substituer à une formation !

« Il faut que les cas de test puissent être exécutés par n’importe qui. » Quand vous entendez cette phrase, vous êtes donc en droit de frémir.

Vous utilisez Squash TM dans une organisation fermée ; ses collaborateurs ne sont pas « n’importe qui ». Une nouvelle recrue n’est pas non plus n’importe qui. Si elle est amenée à tester un applicatif, il est essentiel de lui expliquer la raison d’être de cet applicatif, comment il fonctionne, ce qu’il est important de tester, ce qu’on aimerait savoir à la fin d’une campagne de test. L’étape d’acclimatation fonctionnelle passe à la trappe ? Dans ce cas, ce n’est pas un profil de testeur que l’on intègre dans l’équipe, c’est un profil d’automate, et on se prive d’un précieux cerveau.

Quand on passe une heure à écrire un cas de test en entrant dans les moindres détails, c’est une heure entière que l’on passe à ne pas tester l’application. Et par la suite les testeurs nécessiteront… combien ? Cinq minutes de lecture ? Dix ? Autant de temps qui ne sera pas utilement consacré, et qui sera multiplié d’itération en itération.

Pire peut-être, si le cas de test est trop long, les testeurs fatigueront plus vite, les liront en diagonale, et passeront peut-être à côté de vérifications essentielles.

A vous donc de trouver l’équilibre parfait entre clarté et concision.

Astuce #6 : Des appels de cas de test, intelligemment tu feras

Combinée à l’utilisation des jeux de données, cette fonctionnalité vous fera faire des merveilles. Pour appeler un cas de test dans un autre, c’est-à-dire de l’ajouter comme une étape, il suffit de faire un glisser-déposer du cas de test depuis l’arborescence.

Pour reprendre l’exemple précédent : dès lors qu’un cas de test nécessitera une connexion, nous pourrons appeler le cas de test « Connexion client en fonction de son segment ». Dans l’exemple ci-dessous, nous reprenons un jeu de données renseigné précédemment, mais nous aurions pu aussi le configurer directement dans le cas de test (option « paramètres délégués »).

Un cas de test peut en appeler un autre qui en appelle un autre qui en appelle un autre… aucune contrainte à signaler à ce sujet. Il est également possible d’appeler plusieurs cas de test au sein d’un seul.

Désormais, il y a beaucoup moins de raisons de se répéter !

Cas pratique : une gestion mutualisée des jeux de données

Avez-vous remarqué que sur la page « Informations » d’un cas de test Squash TM, il est possible de renseigner un champ dédié aux prérequis ? Malheureusement, il n’est pas possible de mutualiser ces informations entre plusieurs cas de test ayant besoin des mêmes prérequis.

Nous avons donc parfois recours à un mode de fonctionnement qui nous a permis d’économiser pas mal de temps : au lieu de remplir ce champ de pré-requis (avec le risque d’avoir à maintenir X fois ce champ en cas de changement), nous créons un dossier de cas de test « utilitaires » à appeler à volonté en première étape des cas de test en guise de prérequis.

Il arrive que les jeux de données de certains cas de test soient le résultat d’une requête SQL à lancer au préalable ; c’est donc bien plus pratique de n’avoir à modifier ce script SQL qu’à un seul endroit.

C’est là que la zone « Cas de test appelé par » s’avère très utile ! Dès qu’il faudra changer la requête, il sera possible d’effectuer une revue des impacts possibles, et de s’assurer que la nouvelle requête convient bien à tous les cas de test concernés.

Astuce #7 : Tes cas de test, tu qualifieras

Quand on crée un cas de test sur Squash TM, son champ « Importance » est par défaut alimenté avec la valeur « Faible ».

Si vous ne savez pas quels cas de test sont cruciaux, vous risquez de vous retrouver en difficulté au moment de la conception de votre campagne de test.

Avec Squash TM, il est facile de garder la trace des cas de test les plus importants et de ceux que vous pouvez déprioriser. Faites en sorte que vos cas de test reflètent ce qui est vraiment vital – et ce qui ne l’est pas.

Cela doit devenir un réflexe : ajustez l’importance du cas de test dès sa création !

Astuce #8 : Des périphrases, tu utiliseras

Un dernier coup de pouce pour la rédaction. Si votre interface contient du texte et que ce texte n’est pas l’objet du test, il est inutile de l’indiquer directement dans les étapes du cas de test, sous peine d’occasionner des rapports d’anomalie à faible valeur ajoutée.

Le bouton de validation d’une pop-in peut être amené à changer au fil du temps : il peut en particulier changer d’intitulé (« Ok », « Valider », « Je comprends », « Oui », « D’accord », « Certes », « Pourquoi pas » ou « Tout me va »). Si cela se produit, vous n’avez pas envie d’avoir à mettre à jour une longue liste de tests. Il est donc plus pratique de désigner ce bouton comme « le bouton de validation » (donc, en utilisant une périphrase), plutôt que « le bouton ’Ok’ » ou « le bouton ‘Valider’ ».

Idem pour les messages d’erreur ! « Le message d’erreur indiquant à l’utilisateur que son mot de passe est erroné » est plus robuste que « le message ‘Mot de passe erroné’ », qui pourrait devenir « le message ‘Votre mot de passe est incorrect, merci de le saisir de nouveau’ ».

Conclusion

Quelle que soit votre utilisation de Squash TM, n’oubliez pas que l’objectif est de refléter vos objectifs qualité de la meilleure façon, pour obtenir des référentiels de test pertinents et efficaces. Concentrez-vous donc sur l’optimisation à chaque étape du processus et ce que vous construirez offrira à vos clients ou équipes la meilleure valeur ajoutée possible.

Ces bonnes pratiques ont pour but de vous aider à être plus efficace en travaillant avec ; n’hésitez pas à compléter avec vos propres astuces !

« Selenium c’est terminé, maintenant c’est Cypress ! »

Voilà une terrifiante affirmation quand on utilise Selenium au quotidien et qu’on adore ça ! Mais rien ne sert de se recroqueviller dans ses douillettes habitudes, retroussons nos manches et partons à l’assaut de cette étoile montante, dont on entend si souvent parler.

Cet article s’appuie sur :

• Des questions que nous nous sommes posées avant et pendant notre exploration de cet outil
• Le tutoriel Cypress de l’excellente Test Automation University
• L’hypothèse que si on peut faire une chose avec Selenium, on aura envie de faire la même chose avec Cypress
• L’espoir inavouable de mettre Cypress en défaut… mais à la loyale !

Mais pour commencer, posons les grosses questions qui fâchent !

Cypress est-il payant ?

Etudions cette question en premier car c’est un point crucial pour certaines équipes !

Pour répondre à cette question, il va falloir faire la différence entre 2 produits : l’exécuteur de tests (Test Runner) et le service de reporting associé (Dashboard service). Le premier est totalement gratuit et open-source. Le second est facultatif, et payant à partir de 500 exécutions de tests par mois. En plus des tableaux de bord, il permet de gérer la parallélisation des tests, facilite la mise en place de l’intégration continue (qui reste possible même sans), s’intègre avec Slack, injecte du feedback dans Github… Bref, un super assistant, mais dont on peut se passer s’il le faut.

Quels langages supporte Cypress ?

Le JavaScript, et c’est tout. Vous avez l’habitude de tel ou tel autre langage avec Selenium ? Tant pis, vous apprendrez, ce serait dommage que ce détail vous empêche d’aller plus loin ! D’autant que Cypress offre un DSL (Domain Specific Language) particulièrement fourni. On y reviendra.

Quels navigateurs supporte Cypress ?

Au départ, seul Google Chrome était pris en charge, mais cela a bien changé. A partir de Cypress 4.0, il est possible désormais d’interagir avec Firefox et Edge, et de manière générale cette problématique est inscrite dans la roadmap de Cypress. Restez en veille !

Quid de la documentation et de la communauté Cypress ?

Côté documentation, le site de Cypress est plutôt généreux. Et sa communauté StackOverflow n’est pas en reste, avec plus de 6700 questions sur le sujet. Ce n’est rien comparé à Selenium (bientôt 78 000 questions), mais c’est tout de même un bon signe, surtout si on tient compte de la relative nouveauté de l’outil.

La communauté Cypress est par ailleurs assez active sur Github, et il existe par exemple des initiatives open-source de nature et d’ampleurs assez diverses visant à combler les manques de Cypress. Un exemple ? Cet utilitaire qui permet d’interagir avec la touche de tabulation !

La liste des plugins Cypress (développés ou non par Cypress) est visible ici.

Poursuivons maintenant avec des questions sur le fonctionnement de l’outil.

Cypress, c’est encore une surcouche de Selenium ?

Hé non ! Selenium communique avec le navigateur, alors que Cypress tourne directement dans le navigateur. Voyez le script Cypress confortablement assis dans le code HTML de la page d’accueil de Testeum !

Cela peut d’ailleurs occasionner des comportements inattendus, par exemple des protestations de votre antivirus qui s’emmêle les pinceaux dans les certificats (Kaspersky par exemple ; avec Avast nous n’avons pas rencontré de problème).

Sur quel framework s’appuie Cypress ?

Cypress s’appuie sur le framework de test Mocha (prononcer « moka »), d’où il tire notamment la syntaxe « describe » / « it ». Vous avez peut-être déjà croisé ce framework en JavaScript au détour d’un projet Protractor !

L’identification des objets est-elle similaire à celle à l’œuvre dans Selenium ?

Par défaut, seuls les sélecteurs CSS sont gérés. Heureusement, il existe une librairie permettant d’utiliser les xPaths, qui sont tout de même bien pratiques dans certains cas.

Comment configure-t-on l’environnement de test et ses paramètres ?

Ça se passe dans le fichier qui permet d’indiquer tous les paramètres, à savoir le fichier cypress.json. Là, on indique par exemple la taille souhaitée de la fenêtre de navigateur, les différents time-out, éventuellement une URL de base qui servira de préfixe à chaque appel de page web. Tous ces paramètres sont listés ici.

Peut-on mettre en œuvre le design pattern du Page Object Model avec Cypress ?

Le bon vieux Page Object Model, qu’on retrouve si souvent dans les (bons ?) projets de tests Selenium, permet entre autres de ne déclarer qu’une seule fois tous les éléments d’une page, et d’ainsi réduire son temps de maintenance. Qu’en est-il avec Cypress ?

C’est possible

Le tutoriel de la Test Automation University, tout comme cet article, expliquent comment mettre en œuvre ce design pattern. Si vous venez du monde de Selenium, le dépaysement sera donc minimal si vous souhaitez poursuivre avec cette pratique.

Cypress propose autre chose

Au sujet du Page Object Model, le blog Cypress met en revanche les pieds dans le plat et conseille d’abandonner cette pratique, considérée trop risquée et coûteuse en maintenance (on peut être d’accord ou non !). Ce qui est proposé, c’est de passer directement par les actions de l’application pour la mettre dans l’état qu’on souhaite avant d’opérer la vérification.

Mettons par exemple que l’on souhaite valider la réponse d’un formulaire. Un script de test classique effectuerait d’abord les actions permettant de remplir le formulaire, en « mimant » les actions de l’utilisateur.

Comme Cypress injecte du code JavaScript directement dans le navigateur, une autre possibilité serait de modifier directement le DOM pour que le formulaire soit déjà pré-rempli. L’article donne un exemple intéressant, qui démontre la robustesse et la rapidité de cette méthode. Celle-ci suppose cependant un niveau plus élevé en développement JavaScript. N’oublions pas que Cypress a été développé originellement par des devs front-end pour des devs front-end !

Mais au fait, pourquoi ça s’appelle Cypress ?

Les feuilles du cyprès sont vertes toute l’année et ne tombent jamais. C’est ce que souhaitent à nos tests les créateurs de Cypress !

Maintenant que nous avons fait le tour des questions de base autour de Cypress, pesons maintenant les pours et les contres !

Qu’est-ce qui est indiscutablement mieux que Selenium ?

Son interface de lancement interactif

Cette fonctionnalité est plutôt sympathique, on se croirait dans un cockpit (avec moins de boutons). Il est possible de générer le code de capture d’un objet en cliquant simplement dessus.

Au lancement des tests, toutes les requêtes effectuées sont affichées dans un panneau à gauche de l’écran. Un code couleur permet d’identifier d’un coup d’œil les différents statuts des requêtes. Une fois les tests terminés, ce panneau permet de « remonter le temps » ; on clique sur une des étapes, et l’écran affiché au milieu revient dans l’état spécifié.

Il est bien sûr possible de lancer les tests sans ouvrir cette fenêtre interactive, avec la commande « npx cypress run ». Les tests se jouent alors en mode headless.

En fait, c’est comme si Cypress avait voulu prendre le meilleur de Selenium Webdriver et Selenium IDE (oui, car Selenium IDE a des atouts, et si vous pensez que non c’est que vous n’avez peut-être pas appris ce qui lui est arrivé ces dernières années !).

Sa gestion du temps

Vitesse d’exécution

Cypress est réputé notamment pour sa rapidité, et d’après nos quelques essais, cela semble mérité !

Attente des éléments

Le fait que l’outil gère tout seul l’attente des différents éléments de l’interface est extrêmement confortable.

Voyage dans le passé

Le fait de pouvoir « rembobiner » le test dans l’interface de lancement interactif est aussi très pratique. On peut ainsi savoir exactement à quel moment a eu lieu l’erreur, et se rejouer ce moment à volonté, en ayant en plus accès à l’inspecteur du navigateur !

Ses captures vidéo

Certes, avec Selenium il est possible de se débrouiller pour prendre des screenshots et des captures vidéo, de les stocker où on veut, etc. Ce que Cypress apporte nativement, c’est des enregistrements de vidéos de tous les tests joués, qui sont enregistrés dans un dossier dédié (avec la commande « npx cypress run »). Les vidéos sont nommées à partir du titre des scripts de test, bien clairement. Le dossier des vidéos est par défaut purgé à chaque lancement, mais il est possible de paramétrer cela (toutes les infos ici).

Et ce qui est vraiment sympa, c’est que les vidéos montrent le même panneau d’exécution que dans la fenêtre interactive. On reste dans le cockpit en toutes situations !

Cypress offre quelques possibilités de configuration de cette fonctionnalité.

Ses screenshots

En cas d’échec, un screenshot est aussi automatiquement pris (toujours avec la commande « npx cypress run ») et stocké dans un dossier dédié. Les paramètres de configuration sont listés ici.

De même que pour les vidéos, on voit à la fois l’écran du système à tester et l’interface de lancement, ce qui permet de visualiser quelle erreur a été détectée.

Sur l’exemple ci-dessous, le jeu de données du test génère un faux positif : on attend une page d’accueil avec un H1, mais on reste sur la page de connexion.

Son DSL

Le DSL de Cypress s’appuie sur Chai, qui est particulièrement bien fourni. Nul besoin de créer ses propres fonctions pour vérifier le texte d’un élément, la valeur d’un de ses attributs, la longueur d’une liste d’éléments, et bien d’autres choses encore. Dépendamment de l’IDE utilisé, l’autocomplétion rend la tâche particulièrement réjouissante. Ceci étant dit, n’oublions pas qu’il est aussi possible d’intégrer Chai à Selenium (au parfum JavaScript) et de profiter de ses fonctionnalités.

Cypress ajoute cependant certaines commodités : la syntaxe {enter} (qui permet de simuler un appui sur la touche « Entrée »), {pageup}, {selectall}… Tout est listé ici. Par exemple, on pourrait valider un formulaire aussi simplement que ça : cy.get(‘#input-password).type(« un password incorrect{enter} »);

A l’inverse, quels sont les défauts de Cypress ?

« Il n’y a ni défauts ni qualités, seulement des caractéristiques. » -Un vieux sage

Cypress a une page dédiée à ses limitations, qui sont plutôt présentées comme des choix fonctionnels assumés (on ne peut pas tout faire !) Les voici donc en bon français.

Son périmètre réduit

Ce n’est pas forcément un défaut mais c’est bien d’avoir ça en tête. Cypress n’est pas un outil d’automatisation généraliste. Il se distingue en cela de Selenium, dont la phrase d’introduction est « Selenium automate browsers. That’s it! What you do with that power is entirely up to you. »

Celle de Cypress est plus ciblée : « Cypress can test anything that runs in a browser. »

Sa dépendance au navigateur

Les commandes Cypress tournent dans le navigateur. Cela implique que les contraintes liées au navigateurs doivent être prises en compte en plus des contraintes liées à Cypress même. Notamment, cela complique (un peu) les interactions avec le back-end et les bases de données, mais cela reste tout de même possible.

Sa politique « 1 test = 1 navigateur, 1 onglet, 1 domaine et 1 port »

Cypress ne prévoit pas de gérer plusieurs onglets de navigateurs au sein d’un test, ni de permettre d’utiliser plusieurs navigateurs au sein d’un même test, ni d’interagir avec plus d’un domaine au sein d’un même test, ni plus d’un port de cette adresse. Cela peut être problématique pour jouer certains tests de bout en bout. Noter toutefois qu’il est possible d’interagir avec des sous-domaines différents d’un même nom de domaine.

Sa gestion des iframes

A l’heure actuelle, la gestion des iframes n’est pas simple. Ça peut être un peu embêtant (dans le cas d’un champ de texte riche, comme CKEditor), ou carrément critique (si l’interface de l’application se présente comme une série d’iframes en poupées russes).

C’est donc un point à bien avoir en tête avant de se lancer. En revanche, ne baissons pas les bras, d’autres se sont penchés sur le problème avant nous et ont trouvé des moyens de contournement.

Alors, verdict ?

L’envie était grande de crier à l’effet de mode et d’écrire une nouvelle ode à notre très cher Selenium. Mais face à tant de belles fonctionnalités, il est drôlement tentant de vouloir aller plus loin. Certes, cet article témoigne d’un début d’exploration, il y a sans doute de vilaines embûches que nous n’avons pas encore rencontrées. Quoi qu’il en soit, longue vie à Cypress et bon courage à tous les automaticien.ne.s qui nous lisent, que vous soyez gaga de Selenium, de Cypress, ou des deux !

Bonus : un mot des diplômés de la Wild Code School

Cypress est un outil enseigné à la Wild Code School au sein de la formation des QA. Comme l’indique Mimoun Kissi, responsable pédagogique de cette formation, « Cypress occupera une grande place dans le monde de l’automatisation. Sa facilité d’installation est un élément essentiel pour être utilisé par des profils juniors ou avec des compétences de bases en programmation. » Nous avons rencontré 3 diplômés de la promotion 2020 afin qu’ils nous donnent leur point de vue sur cet outil : Devillers Poaty-Meaty, Soufiane Hannane et Boussad Ouaked.

Selenium VS Cypress

A choisir entre Selenium et Cypress, les trois testeurs interrogés sont unanimes ; Cypress les a séduits par sa simplicité d’installation et de configuration. Devillers Poaty-Meaty explique : « Avec quelques lignes de commandes, je peux lancer mon projet et je peux en plus effectuer des tests d’API et charger les données de test à partir d’une source. »

S’il fallait changer quelque chose à Cypress

Soufiane Hannane rappelle que Cypress supporte simplement le JavaScript, et que cela pourrait pénaliser une personne plutôt habituée à d’autres langages. Il souligne également le fait que Cypress ne soit pas encore compatible avec Internet Explorer et Safari.

Les challenges liés à Cypress

Les trois testeurs mentionnent des challenges liés à la nature même de Cypress, qui n’est pas un outil codeless. Bien qu’il soit simple d’installation et de configuration, et qu’il permette nativement d’éviter un certain nombre de faux positifs, il nécessite un temps de prise en main, en particulier pour concevoir un projet maintenable et scalable (et c’est important…).

Ce temps d’apprentissage est indispensable aussi bien pour des profils débutant en JavaScript, que par exemple pour Boussad Ouaked, qui avait déjà réalisé des projets de développement en utilisant ce langage.

Merci à eux pour ces témoignages !

_____________________________________________

L’automatisation des tests vous intéresse, vous intrigue ou vous passionne ? Ce récap est là pour vous fournir une vue d’ensemble sur ce sujet.

La semaine dernière, nous présentions Promyze (anciennement Themis), une plateforme collaborative agile et ludique permettant d’améliorer en équipe la qualité de code. Nous nous sommes penchés en particulier sur les Ateliers Craft, qui permettent aux équipes de développement d’échanger efficacement sur les bonnes et les mauvaises pratiques au sein de leurs applicatifs. Cette semaine, Promyze répond à quelques-unes de nos questions au sujet des Ateliers Craft.

Les Ateliers Craft au quotidien : quelle temporalité ?

H : Que conseillez-vous pour intégrer la routine des Ateliers Craft dans le quotidien des développeurs ? En Scrum par exemple, quels moments du sprint privilégier ?

P : La temporalité des ateliers va dépendre des cas d’utilisation. Le scénario qui revient régulièrement est celui d’une équipe qui organise des ateliers à chaque sprint, donc soit 1 fois par semaine ou toutes les 2 semaines. Les fins de sprint sont un bon moment pour organiser une rétrospective collective, prendre du recul sur les développements réalisés et échanger sur les pratiques. Ainsi, cela laisse plusieurs jours aux équipes avant la rétrospective pour trouver 10 minutes afin de déposer des tags et suggérer des bonnes pratiques. Les ateliers s’intègrent très bien dans une démarche agile, puisqu’on retrouve l’idée d’interactions collectives et fréquentes et d’amélioration continue. Surtout, cela ritualise un temps d’échange sur le sujet de la qualité de code.

Qui inviter aux Ateliers Craft ?

H : Une entreprise a 3 applications : A, B et C. Son équipe X travaille sur A et B, et son équipe Y travaille sur B et C. Conseillez-vous de laisser chaque équipe se mêler de la qualité de code de ses propres applicatifs seulement ? Ou au contraire conseillez-vous de laisser les ateliers ouverts à tous ?

P : Difficile de généraliser une réponse pour chaque contexte, mais pour les premiers ateliers je préconiserais que chaque équipe travaille sur son propre code, afin de s’approprier le fonctionnement des ateliers et expérimente quelques rétrospectives. Dans un second temps, inviter des personnes externes est une piste intéressante car la richesse des ateliers provient des interactions et des échanges que vont avoir les personnes qui y participent. L’objectif n’est pas de dire “Faites comme ça !”, mais plutôt “Que pensez-vous d’utiliser plutôt cette façon de faire ?”.

Si ces « invités » travaillent sur les mêmes langages et technologies, avoir un regard extérieur est selon moi toujours bénéfique, car non engageant. En effet, l’équipe d’un projet aura toujours le dernier mot, donc il ne s’agit pas d’imposer, mais de suggérer. Le contexte du projet est vraiment primordial, il est donc important que parmi les participants il y ait des membres du projet.

En revanche, nous ne conseillerons pas que l’équipe X organise seule un atelier sur le code du projet C, car elle ne connaît probablement pas le contexte. Par contre, avoir un atelier commun sur le code du projet B avec les équipes X et Y peut être intéressant !

Même si chaque contexte a ses propres règles et bonnes pratiques, c’est important selon nous qu’une organisation définisse un socle commun de bonnes pratiques, que chaque projet viendra enrichir. De plus en plus d’entreprises structurent des “communautés de pratiques” qui vont dans ce sens. Même dans une structure à taille humaine comme chez Promyze, nous nous efforçons d’uniformiser les pratiques sur nos différents projets. Quand une personne change d’équipe, elle a déjà ainsi des repères pour facilement rentrer dans le code !

De la revue à la correction

H : Corriger une mauvaise pratique immédiatement pendant la revue de code est le meilleur moyen de ne pas la laisser tomber aux oubliettes. C’est facile quand la revue se déroule en présentiel, au poste du développeur, mais là ce n’est pas le cas. Comment conseillez-vous de procéder à la correction des mauvaises pratiques identifiées pendant les Ateliers Craft ?

P : Très bonne question qui revient souvent ! Sur ce point, nous sommes d’ailleurs en train de finaliser une fonctionnalité dans Themis qui permettra, lorsqu’on identifie qu’une bonne pratique n’a pas été suivie, de proposer une correction (ex : un refactoring). Cela permettra d’enrichir la documentation de la bonne pratique, et d’échanger avec l’équipe pour savoir si on valide ou non la suggestion de correction. Pour en revenir à la question, nous prônons une démarche d’amélioration continue du code, donc si nous avons identifié des mauvaises pratiques dans l’atelier, le premier objectif sera d’essayer de ne plus l’appliquer sur les prochains développements. Par la suite, si l’on travaille sur du code existant, et qu’on identifie une mauvaise pratique, alors à ce moment-là il peut s’avérer judicieux de le retravailler pour qu’il respecte la bonne pratique définie dans l’atelier. Il faudra évidemment veiller aux risques de régressions, donc coupler les tests et les développements est fondamental. Enfin, la correction à apporter va dépendre du niveau de criticité : s’il y a potentiellement un bug derrière une mauvaise pratique, on sera forcément plus réactif dans le passage à l’action !

Comment organiser les ateliers ?

H : Il est possible de créer des ateliers à volonté. Comment les organiser ? Est-il conseillé par exemple de tenir des ateliers thématiques ? Comment savoir quand un atelier est terminé ?

P : Nous préconisons d’organiser des ateliers thématiques (ex : HTML/CSS, NodeJS, Spring, …), au sein desquels plusieurs sessions pourront être organisées. Il n’y a qu’une seule session en cours par atelier, donc cela facilite l’organisation. Plusieurs ateliers peuvent être créés en parallèle, mais généralement un seul sera actif chaque semaine par équipe. Pour chaque session, une personne dans l’équipe est désignée comme animateur, et aura pour mission de définir le code source sur lequel travailler, d’envoyer des rappels aux participants et enfin d’organiser la rétrospective. Nous préconisons qu’à chaque démarrage de session, la rétrospective soit notée dans l’agenda de l’équipe, cela permet à chacun et chacune de s’organiser ! Enfin, avoir une rotation dans les thématiques permet de rythmer les échanges et d’apporter de la diversité, mais aussi de revenir quelques semaines plus tard sur une thématique avec un regard qui aura peut être évolué.

Enfin, nous préconisons aussi de préparer le prochain atelier dès la fin de la rétrospective, en désignant qui sera la personne en charge de l’organisation et à quelle date on peut planifier la future rétrospective.

Les guégerres de bonnes pratiques

H : Il y a parfois des querelles autour des bonnes pratiques. Typiquement, il n’est pas rarissime de voir deux devs seniors, tous deux excellents, se crêper le chignon sur telle pratique, que X qualifiera de bonne et Y d’antipattern. Comment les Ateliers Craft permettent-ils de sortir de ces impasses ?

P : Effectivement cela peut arriver que, sur le moment, des personnes ne soient pas d’accord sur une bonne pratique. C’est déjà quelque chose de positif, ça montre qu’il y a de la matière pour échanger des arguments et arriver à un consensus ! Mais pour rebondir sur la question précédente, il est important d’avoir une personne qui soit “facilitateur” lors d’une rétrospective, anime les échanges, invite les participants à s’exprimer, … Cette personne doit être en mesure de sentir si un consensus va rapidement être trouvé lors de la rétrospective ou non, et si ce n’est pas le cas, la pratique qui fait débat est temporairement mise de côté, pour laisser le temps à l’équipe d’y réfléchir et d’exposer des arguments. Ce n’est pas évident de trancher à chaud sur des sujets pointus ! Themis proposera d’ailleurs très bientôt une fonctionnalité dans ce sens, un mode “battle” avec un système de vote qui offrira la possibilité d’apporter des arguments “pour” ou “contre”.

Themis vu de l’intérieur

H : Ca va être énorme ! Et chez Promyze, comment utilisez-vous les Ateliers Craft ?

P : Nous utilisons les ateliers une fois par semaine en organisant la rétrospective le vendredi après-midi. C’est une bonne opportunité pour tous et toutes de se retrouver pour parler de qualité de code et terminer la semaine ensemble. Notre objectif est de ne pas dépasser 1 heure, c’est important de borner les échanges. En pratique, nous conseillons à nos utilisateurs de viser 30 à 45 minutes.

Au début, nous avons forcément été les premiers testeurs de cette fonctionnalité, donc plusieurs formats ont été expérimentés (notamment sur le nombre de fichiers, de tags que l’on pouvait poser, …). Cela nous a aidés à optimiser l’utilisation des ateliers et d’en faire profiter nos clients.

Nous définissons la thématique de chaque session d’atelier, et désignons une personne pour animer la future rétrospective de cette session. Nous mettons en place une rotation dans la thématique des ateliers (HTML/CSS, NodeJS, Tests unitaires, …). C’est très positif jusqu’à présent, en plus nous avons dans notre équipe des profils avec des parcours différents, cela amène de la richesse dans nos échanges !

Merci à Promyze d’avoir répondu à nos questions sur Themis. Longue vie à cet outil qui apporte énormément au processus d’amélioration continue !