Premier scénario de tests avec Gatling

Après avoir fait une présentation rapide de Gatling je voulais montrer la rapidité à laquelle on peut mettre en place un projet de tests d’une application web. Au moment d’écrire cet article, la version 2 de Gatling est en cours de réalisation et j’ai donc choisi de partir sur la dernière version stable 1.5.2 (plutôt que sur la 2.0.0-M3).

Si vous voulez des exemples plus complet je vous laisse lire le wiki du projet.

Comment installer Gatling ?
Plusieurs pre-requis pour vous faciliter la vie avec Gatling

• une version de Java. Il faut savoir que Gatling est écrit en Java 6 pour la version 1.X et Java 7 pour la version 2. 
• une version de maven pour pouvoir utiliser l’archetype maven (version >= 3.0.4 dans mon exemple) 
• votre IDE favori avec un plugin Scala (voir IntelliJ, Netbeans, Eclipse) 
• l’archive Gatling disponible sous https://github.com/excilys/gatling/wiki/Downloads que vous devrez dézipper dans un répertoire de travail (sans espace dans le nom si possible). Je nommerai ce répertoire [GATLING_HOME] dans le reste de cet article 

Vous êtes prêts ? C’est parti….

Générer un projet de tests
L’archive Gatling donne les outils pour exécuter les scénario de tests et générer des rapports d’exécution mais vous devez écrire ces scénarios… en Scala… Agggggghhhhhh mais je ne connais pas Scala…

Si c’est la même chose pour vous,  pas de panique car un archetype Maven permet de créer tous les éléments nécessaires pour lancer un Recorder permettant d’écouter les différentes requêtes HTTP et générer des scénarios de tests.

Placez vous dans votre répertoire de projets et lancez la commande suivante pour créer un projet de tests nommé example

mvn archetype:generate -DinteractiveMode=fals -DgroupId=com.javamind.gatling -DartifactId=example -Dversion=1.0 -DpackageName=com.javamind.gatling -DarchetypeGroupId=com.excilys.ebi.gatling.highcharts -DarchetypeArtifactId=gatling-highcharts-maven-archetype -DarchetypeVersion=1.5.2

J’utilise l’archetype pour Gatling 1.5.2. La liste de tous ceux disponibles est présente à l’adresse suivante.

Vous allez devoir adapter votre fichier de configuration de maven (settings.xml) pour accéder aux archetypes et aux dépendances liées mis à disposition sur le repository Maven Gatling.

        
<repository>
 <id>gatling</id>
 <name>Excilys Repository</name>
 <url>http://repository.excilys.com/content/groups/public</url>
</repository>

A la suite de la génération du projet vérifiez qu’il se construit en lançant la commande
mvn clean install

Vous pouvez maintenant ouvrir le projet de tests dans votre IDE

Génération d’un scénario de tests
Prenons un exemple simple avec l’ouverture d’une page web, la saisie d’une valeur et sa soumission. L'exemple est assez simple mais mon but n'est pas de rentrer dans les méandres du produit.

Nous allons enregistrer un scénario en lançant la classe Recorder située dans le répertoire src/test/scala qui permet d’exécuter le module Gatling Recorder.

 

Si vous utilisez un proxy pour vous connecter à Internet vous pouvez comme dans la capture d'écran ci dessus renseigner les informations liées. Une fois que vous avez renseigné les informations de connection, le nom de votre classe de test vous pouvez passer à l'étape suivante en cliquant sur le bouton Start en bas à droite. L’étape suivante consiste à paramétrer votre navigateur web pour appeler le recorder

Par exemple dans Firefox vous pouvez le faire à partir des préférences 

Il ne reste plus qu'à commencer l'enregistrement de votre scénario en tapant l'URL de votre application à tester. Pour mon exemple je suis allez sur mon site http://javamind-fr.blogspot.fr et j'ai lancé une première recherche sur le mot clé java puis une deuxième sur gatling.

Stoppez l'enregistrement et ouvrez la classe générée.

Nous avons maintenant notre premier scénario de tests. Pour ceux qui ont peur de Scala, il faut savoir que vous n'avez pas besoin de connaître le langage pour la plupart des cas. En fait Gatling utilise Scala comme langage de script ce qui lui permet d'exécuter les scénarios sans avoir à les compiler. Le DSL proposé est simple et bien documenté. L'avantage de passer par un langage de programmation est de bénéficier des outils offerts par les IDE (complétion, refactoring, validation....).

Revenons à notre scénario généré qui est un peu compliqué car tous les échanges avec le serveur ont été capturés : chargement des images, des feuilles de styles.... Nous allons faire un peu de ménage pour ne garder que le minimum

class JavamindSimulation extends Simulation {
   val httpConf = httpConfig
      .baseURL("http://safebrowsing-cache.google.com")
      .proxy("proxy.javamind.com", 8080).httpsPort(8080)
      .credentials("ehret_g", "MonPassword")
      .acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
      .acceptEncodingHeader("gzip, deflate")
      .acceptLanguageHeader("fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3")
      .connection("keep-alive")
      .userAgentHeader("Mozilla/5.0 (Windows NT 5.1; rv:24.0) Gecko/20100101 Firefox/24.0")

 val headers_1 = Map(

   "Accept" -> """text/plain, */*; q=0.01""",

   "If-Modified-Since" -> """Mon, 21 Oct 2013 18:09:36 GMT""",
   "If-None-Match" -> """"72026f1a-82bd-4541-8be7-a1cc784bf592"""",
   "Proxy-Authorization" -> """Basic ZzeezezTTTzpJb3JnYSswOA==""",
   "X-Requested-With" -> """XMLHttpRequest"""
 )

 val headers_2 = Map(
   "If-Modified-Since" -> """Mon, 21 Oct 2013 18:09:36 GMT""",
   "If-None-Match" -> """"72026f1a-82bd-4541-8be7-a1cc784bf592"""",
   "Proxy-Authorization" -> """Basic ZzeezezTTTzpJb3JnYSswOA=="""
 )

 val scn = scenario("Recherche article Javamind")
   .exec(
      http("ouverture blog")
        .get("http://javamind-fr.blogspot.fr/")
        .headers(headers_1)
   )
   .pause(2000 milliseconds)
   .exec(
      http("Recherche article java")
        .get("http://javamind-fr.blogspot.fr/search")
        .headers(headers_2)
        .queryParam( """q""", """java""")
   )
   .pause(2000 milliseconds)
   .exec(
      http("Recherche article gatling")
        .get("http://javamind-fr.blogspot.fr/search")
        .headers(headers_2)
        .queryParam( """q""", """gatling""")
   )
 

  setUp(scn.users(1).protocolConfig(httpConf))

}

Comme je le disais plus haut au delà du langage la seule chose qui nous intéresse ici est le DSL proposé. Nous avons à notre disposition un grand nombre de méthodes pour

• décrire les actions des utilisateurs (scenario) : exec, pause 
• injecter des données dans votre scénario (feeder) : pas utilisé dans mon exemple mais utile par exemple pour utiliser des utilisateurs différents quand on simule des connections 
• configurer le scénario (scenario configuration) : users 
• définir les requête HTTP envoyées par le scénario (http action) : http, get, headers, queryParam 
• vérifier les réponses (checks) 
• configurer les appels HTTP (http configuration) : httpConfig, proxy, credentials... 
• contrôler que le résultat correspond aux attentes (assertions)  

Pour résumer un scénario correspond à l’exécution de plusieurs requêtes HTTP (identifier par une méthode, des paramètres, une entête…) entrecoupées de temps de pause. Le scénario est ensuite exécuté pour le nombre d’utilisateurs que vous précisez.

Exécuter le scénario
Il ne vous reste plus qu’à copier le fichier Scala généré dans le répertoire des scénarios Gatling [GATLING_HOME]/user-files/simulation

Lancez ensuite [GATLING_HOME]/bin/gatling.bat. Gatling liste tous les scénarios disponibles. Vous devez choisir le numéro du scénario de test que vous voulez exécuter et définir un id d’exécution

Laissez la simulation s’exécuter.

Résultats des tests
Par défaut, Gatling ne propose pas de résultats en temps réel. Il existe cependant un plugin basé sur Graphite qui permet d’avoir des graphes en temps réel. Je ne parlerai ici que des rapports générés en fin d’exécution et disponible sous [GATLING_HOME]/user-files/simulation

Voici des captures d’écran de ces rapports d'exécution

L'exemple montré dans cet article est un peu simplet mais il a le mérite de montrer les différentes étapes pour en place un scénario de tests.