கேட்லிங் மூலம் Oauth2 அங்கீகாரத்தை எவ்வாறு செய்வது என்பதை இந்த இடுகை விளக்குகிறது.
இந்த எடுத்துக்காட்டில், ஒரு பயனரை உருவாக்க நாங்கள் ஒரு கோரிக்கையை அனுப்புகிறோம். இருப்பினும், பயனர் இறுதிப்புள்ளி பாதுகாக்கப்படுகிறது மற்றும் அணுகல்_டோகன் தேவைப்படுகிறது.
முதலில், ஒரு தாங்கி_டோகன் அல்லது அணுகல்_டோகனைப் பெறுவோம், பின்னர் பயனரை உருவாக்க அடுத்த ஏபிஐ கோரிக்கைக்கு தலைப்பாக அனுப்புவோம்.
இதை விளக்குவதற்கு, நாங்கள் முன்பு கட்டிய கேட்லிங்கிற்கான அதே திட்ட கட்டமைப்பைப் பயன்படுத்துவோம்:
கேட்லிங் மற்றும் மேவனுடன் செயல்திறன் சோதனை கட்டமைப்பு
மேற்கண்ட இடுகையில் உள்ள படிகளைப் பின்பற்றும்போது, எங்கள் திட்ட கட்டமைப்பை பின்வருமாறு வைத்திருப்போம்:
முதலில் | _ _ + _ | இல் எங்கள் OAuth 2.0 அளவுருக்களை வரையறுக்கிறோம் பொருள் கோப்பு கட்டமைப்பு கோப்புறை:
Configuration.scala
குறிப்பு:பொதுவாக, சோதனைகள் இயங்கும் கணினியில் சூழல், கிளையன்ட்_ஐடி மற்றும் கிளையன்ட்_செக்ரெட்டுகள் ஏற்றுமதி செய்யப்படுகின்றன, எனவே நாம் இதைப் பயன்படுத்தலாம் System.getProperty () மதிப்புகளைப் படிக்க.ஒரு தாங்கி டோக்கனைப் பெற அங்கீகார சேவையகத்திற்கு கோரிக்கையை அனுப்பும் குறியீட்டை இப்போது எழுத வேண்டும்.
இந்த கோப்பு 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' }
கீழ் சேமிக்கப்படுகிறது கோரிக்கைகளை எங்கள் திட்ட கட்டமைப்பில் கோப்புறை.
AuthRequest.scala
மேலே உள்ள குறியீடு துணுக்கில், அணுகல்_டோகனை ஒரு கோப்பில் சேமிக்கிறோம்.
மேலே உள்ள அழைப்பு, அணுகல்_டோகனைப் பெறுகிறது.
Access_token ஐ தலைப்பாக அனுப்புவதன் மூலம் பயனரை உருவாக்க எங்களுக்கு மற்றொரு கோரிக்கை தேவை.
எங்கள் பயனர் கோரிக்கை 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
} }
UserRequests.scala
இப்போது நாம் காட்சி பொருளை எழுதுகிறோம். இந்த எடுத்துக்காட்டில் எங்கள் பொருள் 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))) }
UserScenarios.scala
மேலே உள்ள கோரிக்கை, தலைப்பில் ஒரு தாங்கியாக அணுகல்_டோகன் மூலம் ஒரு பயனரை உருவாக்க ஒரு POST கோரிக்கையை அனுப்புகிறது.
இறுதியாக எங்கள் உருவகப்படுத்துதல் கோப்பு 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) }
UserSimulation.scala
நாம் பயன்படுத்தும் சோதனைகளை இயக்க
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)), ) }