OAuth 2.0-Authentifizierung mit Gatling mit Bearer Token

In diesem Beitrag wird erläutert, wie die Oauth2-Authentifizierung mit Gatling durchgeführt wird.

In diesem Beispiel senden wir eine Anfrage zum Erstellen eines Benutzers. Der Benutzerendpunkt ist jedoch geschützt und erfordert ein access_token.

Zuerst erhalten wir ein Bearer_Token oder ein Access_Token und senden es dann als Header an die nächste API-Anforderung, um einen Benutzer zu erstellen.


Um dies zu veranschaulichen, verwenden wir für Gatling dieselbe Projektstruktur, die wir zuvor erstellt haben:

Performance Testing Framework mit Gatling und Maven


Wenn wir die Schritte im obigen Beitrag befolgen, haben wir unsere Projektstruktur wie folgt:



Parameter in der Konfiguration definieren

Zuerst definieren wir unsere OAuth 2.0-Parameter in Configuration.scala Objektdatei unter dem config Mappe:

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' } Hinweis:Normalerweise werden die Umgebung, client_id und client_secrets auf dem Computer exportiert, auf dem die Tests ausgeführt werden, sodass wir die verwenden können System.getProperty () um die Werte zu lesen.

Anfragen

Jetzt müssen wir den Code schreiben, der die Anforderung an den Autorisierungsserver sendet, um ein Inhaber-Token zu erhalten.


OAuth 2.0-Anforderung - access_token

Diese Datei AuthRequest.scala wird unter dem gespeichert Anfragen Ordner in unserer Projektstruktur.

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
} }

Im obigen Code-Snippet speichern wir auch das access_token in einer Datei.

Der obige Aufruf erhält nur das access_token.

Wir benötigen eine weitere Anforderung, um einen Benutzer zu erstellen, indem wir das access_token als Header senden.


Benutzeranfrage

Unsere Benutzeranforderung befindet sich in einer Datei mit dem Namen UserRequests.scala und wird unter dem gespeichert Anfragen Mappe.

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))) }


Szenario

Jetzt schreiben wir das Szenarioobjekt aus. In diesem Beispiel heißt unser Objekt UserScenarios.scala und wird unter dem gespeichert Szenario Mappe.

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) }

Die obige Anforderung sendet eine POST-Anforderung, um einen Benutzer mit dem access_token als Träger im Header zu erstellen.



Simulation

Schließlich unsere Simulationsdatei mit dem Namen UserSimulation.scala wird unter dem gespeichert Simulationen Mappe.


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)), ) }

Um die Tests durchzuführen, verwenden wir

mvn clean gatling:test