Cadre de test de performance avec Gatling et Maven

Quelle est la meilleure façon d'organiser et de structurer un projet Gatling pour les tests de performance?

Lors de la conception d'un framework, nous devons penser à la maintenabilité et à l'extensibilité, donc la façon dont nous organisons les composants est très importante.

Dans ce didacticiel, nous montrerons comment créer un cadre de test de performances à partir de zéro en utilisant Gatling et maven.




Cadre de test Gatling Maven

Conditions préalables:

Pour ce didacticiel, vous devez installer les éléments suivants:


  • Java 1.8
  • Maven 3.5
  • IntelliJ avec le plugin Scala installé

Tout d'abord, nous créons un projet de base en exécutant l'archétype maven Gatling:

mvn archetype:generate -DarchetypeGroupId=io.gatling.highcharts -DarchetypeArtifactId=gatling-highcharts-maven-archetype

Lorsque vous exécutez la commande ci-dessus, il commencera à télécharger les dépendances.

Lorsque vous y êtes invité, indiquez des valeurs pour «groupId», «artifactId» et «version».

Ma configuration ressemble à ceci:


Lorsque vous ouvrez le projet, vous remarquerez qu'il existe des fichiers et des dossiers par défaut.

Sous les ressources, nous avons


corps ce paquet contient les charges utiles de la demande. Par exemple, vous pouvez avoir des modèles de demandes pour diverses demandes.

Les données ce package contient les données dont vous avez besoin pour alimenter vos tests, telles que les CSV.

En plus des deux dossiers ci-dessus, il existe des fichiers Gatling.conf, logback.xml et recorder.conf. Nous n'en discuterons pas dans ce didacticiel.

L'archétype Gatling maven crée également trois objets Scala de base, mais nous ne les utiliserons pas, alors allez-y et supprimez les objets.


De plus, nous créerons quatre packages, config , demandes , scénarios , et simulations :

Package de configuration

Dans le package de configuration, créez un objet Scala appelé Config. Cela contiendra diverses configurations pour notre projet telles que les URL des applications, les utilisateurs par défaut, etc.

package io.devqa.config object Config {
val app_url = 'http://example-app.com'
val users = Integer.getInteger('users', 10).toInt
val rampUp = Integer.getInteger('rampup', 1).toInt
val throughput = Integer.getInteger('throughput', 100).toInt }

Paquet de demandes

Le package de requêtes contient différentes requêtes d'opération. Par exemple, nous pourrions avoir une demande qui obtient un jeton d'autorisation. Une autre demande peut utiliser le jeton de la demande précédente pour créer un utilisateur et ainsi de suite.


Il s'agit de demandes individuelles et isolées envoyées à différents points de terminaison.

GetTokenRequest

package io.devqa.requests import io.gatling.core.Predef._ import io.gatling.http.Predef._ import io.devqa.config.Config.app_url object GetTokenRequest {
val get_token = http('RequestName').get(app_url + '/token')
.check(status is 200)
.check(jsonPath('$..token').saveAs('token')) }

CreateUserRequest

package io.devqa.requests import io.devqa.config.Config.app_url import io.gatling.core.Predef._ import io.gatling.http.Predef._ object CreateUserRequest {
val sentHeaders = Map('Authorization' -> 'bearer ${token}')
val create_user = exec(http('Create User Request')
.post(app_url + '/users')
.headers(sentHeaders)
.formParam('name', 'John')
.formParam('password', 'John5P4ss')
.check(status is 201)
.check(regex('Created').exists)) }

Package Scénarios

Le package de scénarios contient les scénarios commerciaux. Par exemple, pour créer un utilisateur, nous devons d'abord obtenir un jeton d'authentification, puis envoyer le jeton en tant qu'en-tête avec des paramètres de formulaire pour créer un utilisateur. c'est-à-dire que nous utilisons la réponse de la première demande pour alimenter la deuxième demande. Ce «chaînage des requêtes» est assez courant dans les tests d'API.

CreateUserScenario

package io.devqa.scenarios import io.devqa.requests.{CreateUserRequest, GetTokenRequest} import io.gatling.core.Predef.scenario object CreateUserScenario {
val createUserScenario = scenario('Create User Scenario')
.exec(GetTokenRequest.get_token)
.exec(CreateUserRequest.create_user) }

Paquet de simulations

Enfin, nous avons les Simulations dans le package de simulations. Vous pouvez considérer les simulations comme différents profils de charge. Par exemple, nous pouvons avoir une simulation de charge normale ou une simulation de pic.

Les simulations doivent être des classes Scala et elles doivent étendre la classe Gatling Simulation.

package io.devqa.simulations import io.devqa.scenarios.CreateUserScenario import io.gatling.core.Predef.Simulation import io.gatling.core.Predef._ import io.devqa.config.Config._ class CreateUserSimulation extends Simulation {
private val createUserExec = CreateUserScenario.createUserScenario
.inject(atOnceUsers(users))
setUp(createUserExec) }

Votre projet doit ressembler à ceci:

Nous devons également modifier notre fichier pom.xml pour pouvoir transmettre des paramètres, tels que les utilisateurs et le débit, à nos tests de performances lors de l'exécution.

fichier pom.xml

Le fichier pom.xml devrait ressembler à:


4.0.0
testing-excellence
gatling-framework
1.0-SNAPSHOT

1.8
1.8
UTF-8
2.3.0
2.2.4
1.3.2
CreateUserSimulation



io.gatling.highcharts
gatling-charts-highcharts
${gatling.version}
test


com.typesafe
config
${typesafe-config.version}






io.gatling
gatling-maven-plugin
${gatling-plugin.version}



io.devqa.simulations.${simulation}




-Denv=${env}

-Dusers=${users}

-Drampup=${rampup}

-Dduration=${duration}

-Dthroughput=${throughput}




true





Enfin, pour exécuter la classe de simulation, nous exécutons la commande suivante

mvn clean gatling:execute -Dusers=1

La commande ci-dessus exécutera CreateUserSimulation avec 1 utilisateur.