Gain insights into Gatling fundamentals, delve into advanced scripting, simulate network conditions with puppeteer and lighthouse, and set up Jenkins CI for scalable performance testing automation.

performance.tar.gz

Puppeteer

Gatling-1

Java

shell

Lighthouse

gatling-spa-run-framework

gatling-spa-run-framework-copy

Gatling

gatling-local-server

gatling-local-server-live

Almost every company in the world needs to test its scalability and performance of their products or applications.

In this course, you will learn the fundamentals of Gatling, an open-source performance testing tool that is in great demand in the software industry. You will start by learning the basics of performance testing including scalability testing and stress testing.

You will then move on to more advanced concepts such as writing Gatling scripts, understanding web page performance and simulating network throttling using puppeteer and lighthouse tools.

Lastly, you will learn to set up Continuous Integration (CI) using Jenkins for Gatling which will be useful for running tests remotely. By the end of this course, you will have some new great skills for your resume.

Performance Test Automation 101: Gatling, Lighthouse, & Jenkins

In the previous lesson, we learned how to create a basic project structure and the necessary dependencies. In this lesson, we will write our first Gatling test script.

Gatling test scripts need to be written in **Scala** and are quite simple. However, for writing any utility functions, it may require more knowledge of Scala. We highly recommend learning **Scala** in depth if this is required for your uses and projects.

If you want to learn **Scala**, take [this](https://www.educative.io/courses/learn-scala-from-scratch) free beginner’s course on Educative’s platform.

# Sample Gatling test script

In the sample Gatling test script, we will create two scenarios for running **HTTP** requests: one containing **GET** and the other containing **POST**. In both scenarios, we will perform some assertions as well.

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class SampleSimulation extends Simulation {

  val httpProtocol = http
    .baseUrl("http://localhost:8080")
    .acceptHeader("*/*")
    .doNotTrackHeader("1")
    .userAgentHeader(
      "Mozilla/5.0 (Windows NT 5.1; rv:31.0) Gecko/20100101 Firefox/31.0"
    )
    .disableWarmUp
    .disableCaching

  val getScenario = scenario("BasicSimulation - GET")
    .exec(
      http("GET request")
        .get("/")
        .check(status.is(200))
    )

  val postScenario = scenario("BasicSimulation - POST")
    .exec(
      http("POST request")
        .post("https://reqres.in/api/register")
        .body(StringBody("""{ "email": "eve.holt@reqres.in", "password": "pistol" }"""))
        .asJson
        .check(
          status.is(200),
          jsonPath("$.id").exists,
          jsonPath("$.id").find.is("4")
        )
    )

  setUp(
    getScenario.inject(atOnceUsers(1)),
    postScenario.inject(atOnceUsers(1))
  ).protocols(httpProtocol)
}


# Understanding the code

* All Gatling simulation classes need to extend `io.gatling.core.scenario.Simulation`

* **httpProtocol** defines the global configuration for all the HTTP calls.

    - **baseUrl** -- sets the default base URL  for all the requests. It can be overridden for individual HTTP requests.
    - **acceptHeader** -- sets `accept header` in all the requests.
    - **doNotTrackHeader** -- sets a `do not track header` in all the requests.
    - **userAgentHeader** -- sets user agent header in all the requests. 
    - **disableWarmUp** --  In order to compensate for the overhead caused by the Java/NIO engine, Gatling automatically sends a request to https://gatling.io. 
    - **disableCaching** -- Gatling caches responses. To disable it, we can set this option.

* Each simulation file can contain multiple Scenarios, and Gatling allows us to run only one simulation file at a time. The Gatling plugin that we are using allows us to run multiple simulation files, but each one will be run in sequence.

* `Scenario` is a collection of `exec` and each `exec` can be  of the following types:
    - **http** -- for executing HTTP requests. 
    - **ws** -- for executing WebSocket calls.
    - **sse** -- for sending server sent events. 
    - **jms** -- for sending JMS (Java Messaging Service) requests.
    - **session function** -- for passing or manipulating session variables.
    - **collection of exec** -- for adding more **exec** actions with **exec**.

   Scenario names must be unique.

* **BasicSimulation - GET**
 
    ```
    val getScenario = scenario("BasicSimulation - GET")
    .exec(
      http("GET request")
        .get("/")
        .check(status.is(200))
    )
    ```
    Gatling provides an easy to understand DSLs for building the request. In the above example: 
    - We create a scenario named **BasicSimulation - GET**.
    - It consists of an HTTP request, and we name it **GET request**. We do not need a unique name for HTTP requests. However, in the generated report, all the requests with the same name will be grouped together.

    - This HTTP request inherits all the default settings set in **httpProtocol** as given in ***setUp*** method on line 62. 
    - `.get("/")` is the endpoint of the HTTP request, and the base URL is inherited from **httpProtocol**. If we don't want to inherit, we can provide the entire URL here as well.
    - `check` is the assertions that can be applied after receiving the response. In our case, we asserting whether the received HTTP response has status code `200`  

* **BasicSimulation - POST**
 
    ```
    val postScenario = scenario("BasicSimulation - POST")
    .exec(
      http("POST request")
        .post("https://reqres.in/api/register")
        .body(StringBody("""{ "email": "eve.holt@reqres.in", "password": "pistol" }"""))
        .asJson
        .check(
          status.is(200),
          jsonPath("$.id").exists,
          jsonPath("$.id").find.is("4")
        )
    )
    ```
    In this above example: 
    - We create a scenario named **BasicSimulation - POST**.
    - It consists of a HTTP request and we are naming it **POST request**.
    - This HTTP request inherits all the default settings set in **httpProtocol** as given in ***setUp*** method in line 62. 
    - `.post("https://reqres.in/api/register")` is the endpoint of the HTTP request. Here, we have provided the entire URL.
    - `StringBody(...)` is how we append the request body in the JSON string format. Other available body formats are  -- `RawFileBody`,  `ElFileBody`, `PebbleStringBody`, `ByteArrayBody`, and `InputStreamBody`.
    - `asJson` sets the **accept** and **content-type** headers to **application/json**. 
    - `check` is the assertions that can be applied after receiving the response. In our case, we asserting the following: 
        * The received HTTP response has status code `200`  
        * The responding JSON body has field `id` extracted using JsonPath.
        * The responding JSON body has field `id` with `4` value, which is extracted using JsonPath.

* **setUp** method contains the code that is responsible for how our scenario will be simulated.


    ```
    setUp(
        getScenario.inject(atOnceUsers(1)),
        postScenario.inject(atOnceUsers(1))
    ).protocols(httpProtocol)
    ```

   In our case, we are running each of the scenarios that contain a list of **http** execs once at the time of launch. As there are multiple scenarios given, all the scenarios will be run in parallel by default. 

    

    We are also setting **httpProtocol** as a global setting to all the HTTP requests contained in scenarios. This is optional as long as the individual HTTP request contains all the required information.



Introduction

Basics of Performance Testing

Gatling: Load and Stress Testing Tool

Gatling: Script Features

Examples: Simulations Using Gatling

Web Page Performance

Network Throttling

Download Custom Gatling Test Framework

Gatling with Jenkins

Conclusion

Write your First Gatling Test Script Programmatically