Master Performance Testing Gatling + Scala + Jenkins -APR'26

Explore how Scala blends functional and object oriented programming into a concise language on the Java virtual machine, interoperating with Java and offering pattern matching, immutability, and type inference.

Install Scala by configuring Java, including the JVM and JRE, and then complete the Scala installation, following the Gatling prerequisites outlined in the previous lecture.

Set up a Scala project in IntelliJ, verify Scala installation, create an object with a main method, and run a hello world test to confirm the environment is ready.

Explore Scala data types, including numeric types (int, long, float, double), boolean, character, string, reference types, null, unit, and nothing, with examples of explicit typing and string interpolation.

Explore declaring and printing Scala data types such as boolean, character, and string, with explicit type annotations and double quotes, plus notes on static typing.

Explore Scala data types by examining reference types, any ref, null, unit, and nothing, with examples using string, object references, and null handling, plus Scala 3 main method annotations.

Explore how Scala uses var for mutable variables and val for immutable constants, with examples of changing an age and printing the result.

Explore conditional statements in Scala, including if else, else if, the ternary operator, and match expressions with pattern matching, to control code flow.

Explore Scala looping constructs, including while loops, for loops over ranges and collections, and for each loop for concise iteration. Note that do-while is not available in Scala 3.

Learn how to define functions in Scala with the def keyword, specify parameters and return types, use unit for main, and implement an add function that returns x plus y.

Explore five function types in Scala: standalone functions, methods, anonymous (lambda) functions, higher-order functions, and curried functions, with object and class examples and how to call them.

Define an anonymous function assigned to square that takes an int x and returns x * x, call it with 10, and print square result is 100.

Define a function called operate that takes x and y and a function parameter, including anonymous functions, then pass op implementations to add or multiply, illustrating higher order functions.

Explore curried functions in Scala by converting a two-parameter add function into separate parameter lists, illustrating partial application and its advantages in multi-step calls.

Learn how to define Scala classes, declare instance variables, create objects, and implement a say hello method that prints a name and age from class fields.

Learn about Scala constructors, including primary constructors declared in the class signature and secondary constructors using this. See how constructors initialize fields, support default arguments, and create objects.

Explore objects in Scala, including singleton instances, companion objects, and private member access, with practical examples of a counter class, apply methods, and an object for add and 3.14159.

Explore encapsulation in Scala by using private fields, getters and setters, and case classes to manage balance, account number, and interface for deposits and withdrawals.

Explore scala access modifiers—private limits access to the same class or object, protected allows access in subclasses and the same package, and public defaults to package-wide visibility, with nameless object.

Discover scala's immutable collections: list, set, map, vector, and tuple—and how they create new collections on modification, preserving original data, with ordering and unique element behavior.

This lecture covers mutable collections in Scala, including array buffer, list buffer, hash set, and hash map, and demonstrates editing them with plus-equal, add, and put.

Master Scala exception handling by using try, catch, and finally to gracefully manage arithmetic, null pointer, array index out of bound, and general exceptions.

Identify and install four Gatling prerequisites: Java JDK, Scala, Apache Maven, and an IDE (preferably IntelliJ IDEA), and verify compatible Java versions (11, 17, 21).

Explore Gatling 3.11 breaking changes, including the shift to a Maven-based bundle, dropped deprecated methods, and syntax changes like replacing $() with #() while emphasizing Java and TypeScript support.

Install Gatling 3.11 via Maven with Scala, following prerequisites for Java versions, and use the Maven wrapper to run a sample simulation and view the generated report.

Record a user flow with a har file, convert it into a Gatling Scala script, and run the simulation to validate the captured API calls.

Edit the recorded Gatling scripts and give meaningful request names for clarity, then re-run the test locally and verify updated, readable reports from ha and http converters.

Explore the built-in Gatling report, learn to read the global and details tabs, and interpret metrics like active users, response time, percentiles, and throughput for per-api summaries.

Override default report values in Gatling by editing the Gatling.conf under the con folder, adjusting charting percentiles (50, 75, 95, 99) and enabling or disabling reports.

Explore Maven, a build automation and project management tool for Java projects, covering pom.xml, build lifecycle, dependency management, plugins, central repository, convention over configuration, and IDE integration.

Choose manual Gatling scripting over recorder to gain customization, dynamic data handling, reusable components, and improved debugging, maintainability, and version control for evolving, data-driven performance tests.

Learn how to reuse the Maven Scala depository project with Gatling 3.11, clone the Gatling Maven plugin demo Scala repository, and run Maven to execute pre-configured simulations and tests.

Learn to execute Gatling 3.11 scripts, select simulations after compilation, and run tests with mvnw.cmd Gatling:test on Mac and Windows.

Write a Gatling Scala get API test from scratch using a manual script to simulate requests on a dummy API site, and verify responses with reports.

Automate post API testing with Gatling and Scala by creating a user through a post request with a JSON body, and run ten users to generate a test report.

demonstrates automating put api testing with Gatling and Scala, updating a user via json body and a put url, and running a ten-user simulation to validate results.

Automate the delete API test using Gatling by hitting /api/users/2 with ten simulated users and validating a 100% success report.

Automate Gatling tests by loading JSON request bodies from files rather than hard-coded values. Store JSONs in resources data and use raw file body for post and put API tests.

Combine multiple CRUD scenarios into one Gatling test file with get, post, put, and delete. Use a single setup to inject ten users per scenario and generate a unified report.

Add pause time in Gatling test scripts to model realistic user think time, using fixed, random, and custom pauses, including session-based values and DSL expressions.

Add assertions to Gatling tests to verify response status codes, ensuring APIs return expected 200 or 200-series statuses and fail tests when statuses differ.

Learn to assert Gatling response bodies with json path checks, validating fields like id, email, and job across get, post, put, and delete APIs.

Extract data from api responses by saving user id, first name, and last name from the all users call, then verify a single user using those saved values.

Clear caches and cookies in Gatling tests to simulate a new user and measure true performance by flushing HTTP caches and the cookie jar before API calls.