Karate Performance Testing

Tech Talk

by Engineers of Acroquest Myanmar Technology

“Karate Performance Testing” tool which can save developer/tester time & cost

Go to English summary >>

အားလုံးပဲ မင်္ဂလာပါ။ ကျွန်မနာမည် ဇင်နှင်းဝေ ပါ။ DevOps Engineer တစ်ယောက်အနေနဲ့ Acroquest Myanmar Technology မှာ အလုပ်လုပ်ကိုင်လျှက်ရှိပါတယ်။

ကျွန်မ အခု Market ထဲကို performanceမကောင်းတဲ့ထုတ်ကုန်တွေတင်သွင်းမှုကိုတားဆီးပေးဖို့အတွက် အသုံးပြုရ အဆင်ပြေပြီး performanceကိုစစ်ဆေးပေးနိုင်မဲ့ “Karate Performance Testing” tool အကြောင်း example project, test report တွေနဲ့တကွ ပြောပြပါမယ်။

◆ ဘာကြောင့် ဒီtopicကိုဖတ်သင့်တာလဲ?

Performance checking နဲ့ပတ်သက်ပြီး testing resources နဲ့ reporting time ကိုသက်သာချင်သူများအတွက်တော့ ဒီ topic ကအကျိုးရှိစေမယ်ထင်ပါတယ်။ ဘာကြောင့်လဲဆိုတော့
၁) ကွဲပြားခြားနားတဲ့များစွာသော requests and responses အတွက် လွယ်ကူတဲ့ coding ရေးသားနိုင်ခြင်း
၂) Instruction script တွေအတိုင်း automatic testing လုပ်နိုင်တဲ့အတွက် time and cost သက်သာခြင်း
၃ ) ရလာဒ်အသေးစိတ်ကို Graphများဖြင့် စုံလင်စွာ ဖော်ပြထားပေးမှုကြောင့် Project Manager သို့မဟုတ် Leader ကိုတင်ပြရာမှာ အချိန်ကုန်သက်သာခြင်း
တွေကြောင့် ပဲဖြစ်ပါတယ်။

◆ Performance Testing ဆိုတာဘာလဲ။

Software Testing ထဲက Performance testing ဆိုတာ system တစ်ခုမှာ များစွာသော Workload (various requests and responses )တွေရဲ့ responsiveness နဲ့ stability တွေကိုတိုင်းတာစစ်ဆေးပေးတဲ့ Non-Functional testing ပဲဖြစ်ပါတယ်။

Market ဆီကို systemတစ်ခု မတင်သွင်းခင် အဲ့systemရဲ့ performance ကို စီစစ်တိုင်းတာဖို့ဆိုတာ အရမ်းအရေးကြီးပါတယ်။ အကယ်၍များ Marketဆီ systemတစ်ခုတင်သွင်းပြီးမှ အဲ့systemရဲ့ချို့ယွင်းချက် (ဥပမာ- တစ်ချိန်တည်းမှာ requirementအရ  သတ်မှတ်ထားတဲ့ User အရေအတွက်က access လုပ်တာလေးတောင် system down သွားတာမျိုး) ကို သတိထားမိမယ် ဆိုရင်တော့ ကိုယ့် systemကြီး နာမည်ဆိုးထွက်ရုံမက၊ ကိုယ့် company နာမည်ပျက်ရသည်အထိ ထိခိုက်နိုင်ပါတယ်။ အဲ့ဒါကြောင့် ကျွန်မတို့တွေက Market ထဲမတင်သွင်းခင် performance testing ပြုလုပ်ဖို့ကို အရေးကြီးတဲ့အခန်းကနေထည့်သွင်းစဉ်းစားသင့်ပါတယ်။

Testing ပြုလုပ်တဲ့toolတွေများစွာရှိပေမဲ့ ကျွန်မရဲ့လုပ်ငန်းအတွေ့အကြုံပေါ်မှာမူတည်ပြီး Gatling နဲ့ပူးပေါင်းထားတဲ့ “Karate Performance Testing” ကိုရွေးချယ်ပါတယ်။ ဘာကြောင့်လဲဆိုတော့ open-source ဖြစ်တာရယ်၊ များစွာသော Workload တွေကို လွယ်ကူစွာ coding ရေးနိုင်တဲ့အတွက်ရယ် ကြောင့်ပါ။

◆ Karate နဲ့ Gatling ဆိုတာဘာလဲ။

Karate ဆိုတာကတော့ API test-automation, mocks, performance-testing နဲ့ UI-automation တွေကိုတစ်ပေါင်းတစ်စည်းတည်း framework တစ်ခုအဖြစ်ပေါင်းစပ်ထားတဲ့ open-source tool တစ်ခုပါ။ သူ့ရဲ့ရေးပုံရေးနည်းကလွယ်ကူတဲ့အတွက် programmer မဟုတ်တဲ့သူတွေကတောင်ရေးနိုင်ပါတယ်။

Gatling ကတော့ load testing တွေအတွက်အရမ်းကိုကောင်းမွန်တဲ့ open-source တစ်ခုပါ။ ပြီးတော့ ကိုယ့်ရဲ့ configurationပေါ်မူတည်ပြီး ကြည့်ရလွယ်ပြီး smart ဖြစ်တဲ့report ကိုပါထုတ်ပေးနိုင်ပါသေးတယ်။

ဒီလိုလွယ်ကူကောင်းမွန်တဲ့နှစ်ခုပေါင်းစည်းထားတဲ့ (Karate Gatling) ကတော့
၁) API test တွေကို Gatling အသုံးပြုပြီး performance ကို စီစစ်နိုင်ပါတယ်။
၂) Performance စီစစ်ရာမှာ သီးခြားသတ်မှတ်ထားတဲ့ request ကိုပဲ စစ်မလား၊ request အားလုံးကိုပဲ တပေါင်းထဲတစ်ခါတည်း စစ်မလား။ သင့်တော်သလို စီစဉ်နိုင်ပါတယ်။
၃) Failed ဖြစ်တဲ့resultတွေကိုလည်း line numberနဲ့တကွဖော်ပြထားလို့ ပြဿနာရဲ့တည်နေရာကို လွယ်ကူလျင်မြန်စွာရှာဖွေနိုင်ပါတယ်။

◆ Example projectတစ်ခုတည်ဆောက်ခြင်း

အဆင့်-၁။ လိုအပ်ချက်များ

၁) Java (အနည်းဆုံး Java 8)
၂) Maven, Gradle, Eclipse (သို့မဟုတ်) IntelliJ တစ်ခုခုကို install လုပ်ပါ။
( Karate က OpenJDK တစ်ခုတည်းနဲ့လည်း အလုပ်လုပ်နိုင်ပါတယ်)
အခုပြောပြမဲ့ ဥပမာကတော့ Maven ကိုအသုံးပြုထားပါတယ်။ Maven မဟုတ်တဲ့အခြားအရာတွေအတွက်ကတော့ ဒီမှာ ကြည့်ပါ။
၃)ပထမဆုံး base project ကိုသိဖို့ ဒီ link ကနေ clone လိုက်ပါ။
( Git installation ပြီးစီးထားရန်လိုအပ်ပါတယ် )

အဆင့်-၂။ Karateနဲ့ Gatlingအသုံးပြုရန်လိုအပ်သော dependency နဲ့ plugin ကို pom.xmlတွင်ထည့်သွင်းခြင်း

■ karate-gatling dependencyကိုpom.xmlတွင်ထည့်သွင်းပါ။

 <dependency>
     <groupId>com.intuit.karate</groupId>
     <artifactId>karate-gatling</artifactId>
     <version>1.1.0</version>
     <scope>test</scope>
 </dependency> 

■ Gatling maven plugin ကို pom. xmlတွင်ထည့်သွင်းပါ။

<plugin>
   <groupId>io.gatling</groupId>
   <artifactId>gatling-maven-plugin</artifactId>
   <version>${gatling.plugin.version}</version>
   <configuration>
     <simulationsFolder>src/test/java</simulationsFolder>
     <includes>
       <include>CatsSimulation</include>
     </includes>
   </configuration>
   <executions>
     <execution>
       <phase>test</phase>
       <goals>
         <goal>test</goal>
       </goals>
     </execution>
   </executions>
</plugin> 
 

pom.xml မှာ performance testingကို စီစစ်ပေးတဲ့ *.scala file တွေကို <configuration>နဲ့ ကြေညာထားနိုင်တယ်။ မကြေညာထားရင်တော့ project execute လုပ်တဲ့အခါ command line ကနေတစ်ခါတည်း run ချင်တဲ့ *.scala file ကိုထည့်ပေးရပါမယ်။
ဥပမာ။ ။ mvn clean test -Dgatling.simulationClass=mock.CatsSimulation

အဆင့်-၃။ Karate scenarioတွေအတွက် Gatling load test ကို createလုပ်ပါ။

■ Gatlingက timing တွေကိုတိုင်းတာပြီး threadတွေကို manageလုပ်နေချိန်မှာ HTTP request တွေပြုလုပ်ဖို့ karateProtocol() ကို configure လုပ်ပါ။

val protocol = karateProtocol() 

■ Segregation of requestတွေကို controlလုပ်ပေးရန်အတွက် nameResolver ကိုသတ်မှတ်ပါ။

 protocol.nameResolver = (req, ctx) => req.getHeader("karate-name") 

ဒီအဆင့်က optional ပါ။ များသောအားဖြင့် URI နဲ့ request-pathတွေက constant ပဲချန်ထားခဲ့မျိုး၊ payloadလေးပဲပြောင်းလဲတဲ့ GraphQL နဲ့ SOAP တွေအတွက် သတ်မှတ်ပါတယ်။

■ Performance test စစ်ချင်တဲ့ karate.feature file တွေနဲ့ connect လုပ်ပါ။ karateFeature() က flow တစ်ခုအဖြစ် Karate feature file တစ်ခုလုံးကို declare လုပ်ပါတယ်။

val create = scenario("create").exec(karateFeature("classpath:mock/cats-create.feature")).exec(session => {
   println("*** id in gatling: " + session("id").as[String])
   println("*** session status in gatling: " + session.status)
   session
 })
 val delete = scenario("delete").group("delete cats") {
   exec(karateFeature("classpath:mock/cats-delete.feature@name=delete"))
 }
 val custom = scenario("custom").exec(karateFeature("classpath:mock/custom-rpc.feature")) 

karate feature file ဆိုတာ HTTP requests တွေပေါ်မှာ ကိုယ် testing စစ်ချင်တဲ့ plain script တွေရေးထားတဲ့ file တစ်ခုဖြစ်ပါတယ်။
ဥပမာအားဖြင့် mock/cats-create.feature

Feature: cats crud
 
   Background:
     * url baseUrl 
 
   Scenario: create, get and update cat
     Given request { name: 'Billie' }
     When method post
     Then status 200
     And match response == { id: '#uuid', name: 'Billie' }
     * def id = response.id 

ဒီ sample project မှာသုံးထားတဲ့ karate.feature files တွေကို ဒီမှာကြည့်နိုင်ပါတယ်။

■ Performance (load) testingအတွက် set up လုပ်ပါ။

setUp(
   create.inject(rampUsers(10) during (5 seconds)).protocols(protocol),
   delete.inject(rampUsers(5) during (5 seconds)).protocols(protocol),
   custom.inject(rampUsers(10) during (5 seconds)).protocols(protocol)
 ) 

အခုအသုံးပြုထားတဲ့ load model က rampUsers ပါ။ အဓိပ္ပါယ်ကတော့ သတ်မှတ်ထားတဲ့အချိန်အတွင်း သတ်မှတ်ထားတဲ့ ramdom user အရေအတွက်သည် ကိုယ်စစ်ချင်တဲ့ system ရဲ့ process ကို တပြိုင်တည်း အလုပ်လုပ်မှာပါလို့ ဖွင့်ဆိုပါတယ်။

တခြားသော load model တွေအသုံးပြုမယ်ဆိုရင်တော့ အောက်ပါ link ကနေ‌တစ်ဆင့် ရွေးချယ်အသုံးပြုနိုင်ပါတယ်။

https://gatling.io/docs/gatling/reference/current/core/injection/

■ source code အပြည့်အစုံ ( CatsSimulation.scala )

package mock

import com.intuit.karate.Runner
import com.intuit.karate.gatling.PreDef._
import io.gatling.core.Predef._

import scala.concurrent.duration._

class CatsSimulation extends Simulation {

  MockUtils.startServer(0)

  val protocol = karateProtocol(
    "/cats/{id}" -> Nil,
    "/cats" -> pauseFor("get" -> 15, "post" -> 25)
  )

  protocol.nameResolver = (req, ctx) => req.getHeader("karate-name")
  protocol.runner.karateEnv("perf")

  val create = scenario("create").exec(karateFeature("classpath:mock/cats-create.feature")).exec(session => {
    println("*** id in gatling: " + session("id").as[String])
    println("*** session status in gatling: " + session.status)
    session
  })
  val delete = scenario("delete").group("delete cats") {
    exec(karateFeature("classpath:mock/cats-delete.feature@name=delete"))
  }
  val custom = scenario("custom").exec(karateFeature("classpath:mock/custom-rpc.feature"))

  setUp(
    create.inject(rampUsers(10) during (5 seconds)).protocols(protocol),
    delete.inject(rampUsers(5) during (5 seconds)).protocols(protocol),
    custom.inject(rampUsers(10) during (5 seconds)).protocols(protocol)
  )

}

◆ Test commandကို execute လုပ်ခြင်း

pom.xml မှာ<execution>phase ကိုကြေညာထားတဲ့အတွက် ‘mvn clean test’ command နဲ့ project ကိုexecute လုပ်ပါမယ်။

mvn clean test

အကယ်၍ Gatling simulation file တွေအများကြီးရှိမယ် ၊ ကိုယ်ကတစ်ခုတည်းပဲ စစ်ချင်တယ်ဆိုရင် အောက်ပါ commandကို အသုံးပြုလို့ရပါတယ်။

mvn clean test -Dgatling.simulationClass=mock.CatsSimulation 

◆ Test Report

Execution ပြီးသွားရင် result report ကို ဒီ directory ({project-directory}/target/gatling/{simulationName}/index.html) မှာကြည့်ရှုနိုင်ပါတယ်။

■ Global Gatling execution result

Standard range တွေမှာresponse timeတွေဘယ်လိုdistributeလုပ်လဲဆိုတာ ဒီ chartမှာကြည့်နိုင်ပါတယ်။ ညာဖက်panel က OK/KO request အရေအတွက်ကိုဖော်ပြပေးတယ်။ ပြီးတော့ အောက်က လိမ္မော်ရောင်panel က တစ်ချို့ standard statistics ဖြစ်တဲ့ min, max, average, standard deviation နဲ့ percentile တွေကို globally နဲ့ request တစ်ခုချင်းစီအတွက်ဖော်ပြပေးနိုင်ပါတယ်။
OK : success           
KO : failure

ဒီ Global chart ကိုကြည့်ခြင်းအားဖြင့် performance test လုပ်ထားတဲ့ result ကိုအကြမ်းဖျဉ်းသိနိုင်ပါတယ်။ “Number of requets” chart မှာ success ဖြစ်တာရော fail ဖြစ်တဲ့အခြေအနေကြောင့် performance မှာပြဿနာတစ်ခုခုရှိနေတာသိနိုင်ပါတယ်။ ဘယ်နေရာက ပြဿနာဖြစ်နေလဲဆိုတာ အောက်က လိမ္မော်ရောင် Statistics panel မှာ request တစ်ခုချင်းစီရဲ့ အခြေအနေကိုကြည့်နိုင်ပါတယ်။ ပုံအရ cats ကိုဆွဲထုတ်တဲ့ Get method ပါ၀င်တဲ့ file မှာ ပြဿနာရှိနေတာပါ။
အဲ့ file name နဲ့ error cause ကိုလည်း လိမ္မော်ရောင် Errors panel မှာ သိနိုင်ပါတယ်။ create.feature fileမှာ request ကနေရလာတဲ့ response မှာပါ၀င်လာတဲ့ name နဲ့ excepted name နဲ့မကိုက်ညီတာကြောင့် ပြဿနာဖြစ်လာရတာဖြစ်ပါတယ်။ Error detail ကိုတော့ karate console log မှာ စီစစ်နိုင်ပါတယ်။

■ Active users over time

Simulationအတွင်း active ဖြစ်တဲ့ users တွေကို total နဲ့ scenario တစ်ခုချင်းစီအတွက် ဖော်ပြပေးတဲ့ chart ပါ။
Active user ဆိုတာ “concurrent users” ရော “users arrival rate” ရော မဟုတ်ပါဘူး။ open and closed workload model နှစ်ခုလုံးကိုအလုပ်လုပ်ပေးသော၊ ပေးထားတဲ့ 1 sec တွင် system load ‌ မှာ active ဖြစ်ခဲ့တဲ့ user များကိုဖော်ပြပေးသော mixed metric တစ်ခုဖြစ်ပါတယ်။

■ Response time percentiles over time

အချိန်နဲ့အမျှ successful request တွေချည်းအတွက်သာဖြစ်သော များစွာသော response time percentile တွေကိုသာပြပေးတဲ့ chart ပါ။
Failed requestတွေက အချိန်မတိုင်ခင်အဆုံးသတ်နိုင်တယ် သို့မဟုတ် အချိန်ကုန်ခြင်းကြောင့်ဖြစ်စေတယ် အတွက်ကြောင့် အဲ့ requestတွေက percentile တွက်ချက်မှုအပေါ်မှာသက်ရောက်မှုရှိမှာဖြစ်ပါတယ်။

■ Responses per second over time

အချိန်နဲ့အမျှ 1secမှာလက်ခံရရှိတဲ့ response အရေအတွက် total , success နဲ့ failure တွေကို ဒီ chart ကဖော်ပြပေးပါတယ်။

■  create.inject(rampUsers(10) during (5 seconds)).protocols(protocol),
    ( 5sec အတွင်း random user 10ယောက် create လုပ်တဲ့ result )

delete.inject(rampUsers(5) during (5 seconds)).protocols(protocol)
    ( 5sec အတွင်း random user 5ယောက် delete လုပ်တဲ့ result )

ဒီအကြောင်းအရာလေးက အားလုံးအတွက် အသုံးဝင်ပြီး projectမှာ ပြန်လည်အသုံးချနိုင်ဖို့မျှော်လင့်ပါတယ်။ နောက်လာမယ့်topicတွေလည်း စောင့်မျှော်ကြပါဦး။ (^^)

[ English Summary ]

Hello! This is Zin Hnin Wai, a DevOps Engineer from Acroquest Myanmar Technology.

This topic, Karate Performance Testing is for the developer/tester who wants to save machine resources, cost and reporting time about performance result. Because it will introduce how we can easily develop load testing for multiple and different load models, create automatic testing with easy instruction script and report the result with complete graph to Project Leader or Manager.

◆ What is Performance Testing?

Performance testing, a non-functional testing technique performed to determine the system parameters in terms of responsiveness and stability under various workload. Performance testing measures the quality attributes of the system, such as scalability, reliability and resource usage.

There are many performance checking tools but based on my experience, I prefer to choose “karate performance test with Gatling” because it is open-source, easy to code product’s stability under various workload.

◆ What is Karate and Gatling?

Karate is the open-source tool to combine API test-automation, mocks, performance-testing and even UI-automation into a single, unified framework. It does not require Java knowledge and even non-programmers can write tests because scripts are plain-text.

Gatling is a powerful open-source load testing solution. It is designed for continuous load testing and integrates with the development pipeline. At the end of test, it automatically generates an exhaustive, dynamic and colorful report.

Integration karate with Gatling (Karate Gatling) is very useful to

  1. Reuse Karate API tests as performance tests with Gatling
  2. Track of performance for specific requests or for all requests at once
  3. See Karate report with line numbers that failed.

◆ Test Report

After executing one of the commands below, you can see the result (attached screen capture) at ({project-directory}/target/gatling/{simulationName}/index.html). Please make sure <execution> phase is already set up inside “configuration” of pom.xml.

General

mvn clean test 

Only one simulation file among multiple simulation file

mvn clean test -Dgatling.simulationClass=mock.CatsSimulation 

I hope that this topic will be effective for you and can be applied in your projects. Stay tuned for more topics. (^^)

★★★We are hiring the staff who are interested in latest technologies.★★★

If you are interested in our company, please see the available job descriptions in the following links.

Senior Frontend/ Backend Developer : https://www.acromyanmar.com/senior-frontend-backenddeveloper/


Check our Facebook Page!