Authentification OAuth 2.0 avec Gatling à l'aide d'un jeton de support

Cet article explique comment faire l'authentification Oauth2 avec Gatling.

Dans cet exemple, nous envoyons une demande de création d'un utilisateur. Cependant, le point de terminaison de l'utilisateur est protégé et nécessite un access_token.

Tout d'abord, nous obtiendrons un bearer_token ou un access_token, puis nous l'enverrons comme en-tête à la prochaine demande d'API pour créer un utilisateur.


Pour illustrer cela, nous utiliserons la même structure de projet pour Gatling que nous avons construite précédemment:

Cadre de test de performance avec Gatling et Maven


Lorsque nous suivons les étapes de l'article ci-dessus, nous aurions la structure de notre projet comme suit:



Définition des paramètres dans la configuration

Nous définissons d'abord nos paramètres OAuth 2.0 dans le Configuration.scala fichier objet sous le config dossier:

object Configuration { val environment: String = System.getProperty('environment') val clientId: String = System.getProperty('CLIENT_ID') val clientSecret: String = System.getProperty('CLIENT_SECRET') val apiURL: String = 'https://some-sub-domain.' + environment + 'some-domain.com/api' var tokenPath: String = 'https://some-sub-domain' + environment + '.eu.auth0.com/oauth/token' val userPath = '/identity/iaa/v1/users' } Noter:Normalement, l'environnement, client_id et client_secrets sont exportés dans la machine sur laquelle les tests seront exécutés, nous pouvons donc utiliser le System.getProperty () pour lire les valeurs.

Demandes

Nous devons maintenant écrire le code qui envoie la demande au serveur d'autorisation pour obtenir un jeton de support.


Requête OAuth 2.0 - access_token

Ce fichier AuthRequest.scala est enregistré sous le demandes dossier dans notre structure de projet.

import java.io.{BufferedWriter, FileWriter} import config.Configuration import io.gatling.core.Predef._ import io.gatling.http.Predef._ object AuthRequest { val getAccessToken = exec(http('Get access token')
.post(Configuration.tokenPath)
.body(StringBody(
s'''{

'client_id': '${Configuration.clientId}',

'client_secret': '${Configuration.clientSecret}',

'audience': 'https://some-domain-name.com/user',

'grant_type': 'client_credentials',

'scope': 'user:admin'
}'''
))
.asJson
.headers(Map('Content-Type' -> 'application/json'))
.check(status.is(200))
.check(jsonPath('$.access_token').saveAs('access_token')))
.exec {
session =>
val fw = new BufferedWriter(new FileWriter('access_token.txt', true))
try {

fw.write(session('access_token').as[String] + ' ')
}
finally fw.close()
session
} }

Dans l'extrait de code ci-dessus, nous enregistrons également le jeton d'accès dans un fichier.

L'appel ci-dessus, obtient juste le access_token.

Nous avons besoin d'une autre demande pour créer un utilisateur en envoyant le access_token comme en-tête.


Demande de l'utilisateur

Notre demande d'utilisateur se trouve dans un fichier appelé UserRequests.scala et est enregistré sous le demandes dossier.

import config.Configuration.{apiURL, userPath} import io.gatling.core.Predef._ import io.gatling.http.Predef._ object UserRequests { private val auth0Headers = Map(
'Accept' -> 'application/json, text/javascript, */*; q=0.01',
'Content-Type' -> 'application/json',
'Authorization' -> 'Bearer ${access_token}') val createUser = exec(http('Create user')
.post(apiURL + userPath)
.headers(auth0Headers)
.body(ElFileBody('createUser.json'))
.check(status.is(201))) }


Scénario

Maintenant, nous écrivons un objet de scénario. Dans cet exemple, notre objet s'appelle UserScenarios.scala et est enregistré sous le scénario dossier.

import requests.{AuthRequest, UserRequests} import io.gatling.core.Predef._ object UserScenarios { var userIds:Array[Map[String,String]] =
(100 to 900).toArray map ( x => { Map( 'userId' -> x.toString) }) val getAccessToken = scenario('Get token')
.exec(AuthRequest.getAccessToken) val createUserScenario = scenario('Create user')
.feed(userIds.circular)
.exec(UserAuthZRequest.getAccessToken)
.exec(UserRequests.createUser) }

La demande ci-dessus envoie une demande POST pour créer un utilisateur avec le access_token comme support dans l'en-tête.



Simulation

Enfin notre fichier de simulation appelé UserSimulation.scala est enregistré sous le simulations dossier.


import scenario.UserScenarios import io.gatling.core.Predef._ import scala.concurrent.duration._ class UserSimulation extends Simulation { setUp(
UserScenarios.createUserScenario.inject(rampUsers(250) during (15 minutes)), ) }

Pour exécuter les tests que nous utilisons

mvn clean gatling:test