შესრულების ტესტირების ჩარჩო გეტლინგთან და მევენთან ერთად

რომელია საუკეთესო მეთოდი Gatling- ის პროექტის ორგანიზებისა და სტრუქტურირებისთვის შესრულების ტესტირებისთვის?

ჩარჩოს შემუშავებისას უნდა ვიფიქროთ შენარჩუნებაზე და გაფართოებაზე, ამიტომ მნიშვნელოვანია კომპონენტების ორგანიზება.

ამ სახელმძღვანელოში ჩვენ გაჩვენებთ თუ როგორ უნდა შექმნათ შესრულების ტესტირების ჩარჩო ნულიდან Gatling- ისა და maven- ის გამოყენებით.

Gatling Maven ტესტი ჩარჩო

წინაპირობები:

ამ სახელმძღვანელოსთვის საჭიროა შემდეგი ინსტალაცია:

  • ჯავა 1.8
  • Maven 3.5
  • დაინსტალირებულია IntelliJ Scala მოდულით

პირველი, ჩვენ ვქმნით ბაზის პროექტს Maven Gatling- ის არქეტიპის გაშვებით:

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

როდესაც შეასრულებთ ზემოთ მითითებულ ბრძანებას, ის დაიწყება დამოკიდებულებების ჩამოტვირთვა.

მოთხოვნისთანავე მიუთითეთ მნიშვნელობები 'groupId', 'artifactId' და 'version'.

ჩემი დაყენება შემდეგნაირად გამოიყურება:

პროექტის გახსნისას შეამჩნევთ, რომ არსებობს რამდენიმე ნაგულისხმევი ფაილი და საქაღალდე.

რესურსების მიხედვით, ჩვენ გვაქვს

სხეულები ამ პაკეტში ინახება მოთხოვნის დატვირთვები. მაგალითად, შეგიძლიათ გქონდეთ თხოვნების შაბლონები სხვადასხვა მოთხოვნებისთვის.

მონაცემები ამ პაკეტში მოცემულია მონაცემები, რომლებიც გჭირდებათ თქვენი ტესტების შესანახად, როგორიცაა CSV.

ზემოთ ჩამოთვლილი ორი საქაღალდის გარდა, არსებობს Gatling.conf, logback.xml და recorder.conf ფაილები. ჩვენ არ ვისაუბრებთ ამაზე ამ სახელმძღვანელოში.

Gatling maven- ის არქეტიპი ასევე ქმნის სამ ბაზის Scala ობიექტს, მაგრამ ჩვენ მათ არ გამოვიყენებთ, ამიტომ წადით და წაშალეთ ობიექტები.

გარდა ამისა, ჩვენ შევქმნით ოთხ პაკეტს, კონფიგურაცია , თხოვნებს , სცენარები და სიმულაციები :

კონფიგურაციის პაკეტი

კონფიგურაციის პაკეტში შექმენით Scala ობიექტი სახელწოდებით Config. ეს გამართავს სხვადასხვა კონფიგურაციებს ჩვენი პროექტისთვის, როგორიცაა პროგრამის URL, ნაგულისხმევი მომხმარებლები და ა.შ.

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 }

მოთხოვნების პაკეტი

მოთხოვნების პაკეტი შეიცავს სხვადასხვა ოპერაციის მოთხოვნებს. მაგალითად, შეიძლება გვქონდეს მოთხოვნა, რომელიც მიიღებს ავტორიზაციის ნიშანს. სხვა მოთხოვნას შეუძლია გამოიყენოს წინა თხოვნის ჟეტონი მომხმარებლის შესაქმნელად და ა.შ.

ეს არის ინდივიდუალური და იზოლირებული მოთხოვნები, რომლებიც იგზავნება სხვადასხვა წერტილამდე.

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

სცენარების პაკეტი

სცენარის პაკეტი შეიცავს ბიზნეს სცენარებს. მაგალითად, მომხმარებლის შესაქმნელად, პირველ რიგში, უნდა მივიღოთ auth ნიშანი და შემდეგ გავაგზავნოთ ნიშანი როგორც სათაური, ფორმის პარამეტრებთან ერთად მომხმარებლის შესაქმნელად. ანუ ვიყენებთ პირველი მოთხოვნის პასუხს მეორე მოთხოვნის შესასრულებლად. ეს 'მოთხოვნების ჯაჭვობა' საკმაოდ ხშირად გვხვდება 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) }

სიმულაციური პაკეტი

დაბოლოს, სიმულაციები გვაქვს სიმულაციების პაკეტში. თქვენ შეგიძლიათ იფიქროთ სიმულაციებზე, როგორც სხვადასხვა დატვირთვის პროფილებზე. მაგალითად, ჩვენ შეგვიძლია ნორმალური დატვირთვის სიმულაცია ან მწვერვალის სიმულაცია.

სიმულაციები უნდა იყოს Scala კლასები და მათ უნდა გააგრძელონ 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) }

თქვენი პროექტი უნდა გამოიყურებოდეს შემდეგნაირად:

ჩვენ ასევე უნდა შევცვალოთ ჩვენი pom.xml ფაილი, რომ შეძლოთ პარამეტრების, როგორიცაა მომხმარებლებისა და გამტარუნარიანობის გავლა, ჩვენი შესრულების ტესტებზე მუშაობის დროს.

pom.xml ფაილი

Pom.xml ფაილი უნდა გამოიყურებოდეს:


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





დაბოლოს, სიმულაციური კლასის შესასრულებლად, ჩვენ ვაწარმოებთ შემდეგ ბრძანებას

mvn clean gatling:execute -Dusers=1

ზემოთ მოცემული ბრძანება აწარმოებს CreateUserSimulation- ს 1 მომხმარებელთან ერთად.

საინტერესო სტატიები