Gatling CheatSheet

import io.gatling.core.Predef._
import io.gatling.http.Predef._

class SimplestSimulation extends Simulation {
  setUp(scenario("Petstore")
    .exec(http("Home").get("http://10.34.199.64:8000/petstoreee7-7.0"))
    .inject(atOnceUsers(1)))
}   

setUp(scenario("Hello")
    .exec(http("World").get("http://www.google.fr"))
    .inject(atOnceUsers(1)))
    .protocols(http.proxy(Proxy("proxy", 3128)))}   

http("name")
  .get("http://www.google.fr")
  .queryParam("query", "gatling")
  .queryParam("source", "mobile")
  .header("Accept-Language", "fr")

http("name")
  .post("http://mysite.com/users")
  .formParam("firstname", "gatling")
  .formParam("lastname", "stress tool")
  .header("Accept-Language", "fr")

http("name")
  .post("http://mysite.com/users")
  .body(RawFileBody("bodyFileName.xml")).asXml
  .header("Content-type","application/json")

// or 
body(RawFileBody("bodyFileName.json")).asJSON

scenario("sample")
  // ...
  .pause(2, 3) // will make a random pause of 2-3 seconds
  .pause(2) // will make a fixed pause of 2 seconds  

scenario("sample")
  // ...
  .pause(200.milliseconds) // fixed pause of 0.2 second

import scala.concurrent.duration.DurationInt

scenario("sample")
  .repeat(3)( // repeat 3 times
  	 exec(http("google").get("http://www.google.fr"))
  )

val scn=scenario("My Scenario")

setUp( 
  scn.inject( 
    nothingFor(4.seconds), 
    atOnceUsers(10), 
    rampUsers(10) over(5.seconds))

rampUsers(10) over(5.seconds) 
// linear rampup 
// 10 users added over 5 seconds (1 extra user every 500 ms)

constantUsersPerSec(10) during(5.seconds) 
// adds 10 users every second
// (so a total of 50 users after 5 seconds)

nothingFor(4.seconds)
// no new users added during 4 seconds

atOnceUsers(10)
// 10 users added immediately
// not really recommended since it can hammer down the tested server

heavisideUsers(10) over(2.seconds)
// better approximation of a peak of users

http("name").get("/path")
  .check(status.is(200))
  .check(jsonPath("$.name").is("some name"))

http("name").get("/path")
  .check(header("location").saveAs("newLocation"))
  .check(jsonPath("$.name").saveAs("name"))
  
// You can now use $newLocation and $name in your requests :
http("get home").get("/users/${name}")

setUp(scn).assertions( 
  global.responseTime.mean.lt(50), // mean resp time < 50 ms    
  forAll.failedRequests.percent.gt(5) // for each request, < 5% failure
)
// data : responseTime (in milliseconds), requestsPerSec
// requests : allRequests, failedRequests, successfulRequests
// units : percent, permillion, count
// aggregations : min, max, mean, stdDev, percentile1 to percentile4
// comparison : lt(threshold), gt(threshold), between(thresholdMin, thresholdMax), 
//              is(value), in(sequence)

// 3 static entries with keys "foo", "bar"
val feeder1 = Array( 
  Map("foo" -> "foo1", "bar" -> "bar1"), 
  Map("foo" -> "foo2", "bar" -> "bar2"), 
  Map("foo" -> "foo3", "bar" -> "bar3"))

// repeating the values 
val feeder1a = feeder1.circular
val feeder1b = feeder1.random

// infinite entries with keys "value1", "value2"
val feeder2 = Iterator.continually(Map("value1" -> 100, "value2" -> "toto"))

// infinite random entries 
val feeder3 = Iterator.continually(Map(
  "value1" -> Random.nextInt(100),
  "value2" -> Random.alphanumeric.take(4)))

// using the feeder to build the URLs
scenario("scn name")
  .feed(feeder)
  .exec(http("request name")
    .get("/path/${value1}"))

// reading a csv file to build a feeder
val feeder = csv("data.csv")
// the csv file must have a header row which defines the keys and be comma (,) separated

// filling a template file with the content of a feeder
scn.feed(feeder).exec(
  http("name")
  .post("url")
  .body(ElFileBody("filename.xml")).asXML))

val config = ConfigFactory.load("gatling.conf")

val maxPlot = config.getInt("gatling.charting.maxPlotPerSeries")