Design and Execute Gatling Load Tests

This skill builds Gatling load test simulations, protocol configurations, scenario design, and performance analysis, built on six core principles: leveraging Gatling's asynchronous, non-blocking architecture for maximum virtual-user capacity, designing realistic multi-step user journeys rather than isolated requests, properly configuring HTTP/WebSocket/JMS protocols with headers and connection pooling, using appropriate ramp-up strategies for load injection, defining meaningful performance assertions and SLA thresholds, and using feeders for parameterized, session-aware testing.

It provides a complete basic HTTP simulation template (protocol configuration, a two-request scenario with response-time checks, ramp-up plus constant-rate injection, and global assertions on max response time, percentile latency, and success rate) and a multi-stage e-commerce user journey (homepage, login with CSRF token extraction, product browsing, a repeated product-view loop, and add-to-cart). Data management covers CSV, JSON, and custom feeders for parameterized requests. Load injection strategies cover gradual ramp-up, sudden spike testing (atOnceUsers), and stress testing with a Heaviside step function. It also covers error handling and retry logic for unstable endpoints, WebSocket simulations (connect, send, close with message checks), performance assertions and throttling (holding a target requests-per-second rate for a duration then stepping to another), and environment-specific configuration via system properties for base URL, user count, and duration.

val httpProtocol = http
  .baseUrl("https://api.example.com")
  .acceptHeader("application/json")
  .contentTypeHeader("application/json")
  .userAgentHeader("Gatling Load Test")
  .connectionHeader("keep-alive")
  .maxConnectionsPerHost(10)
  .shareConnections

Use this skill when writing or tuning Gatling load test simulations - designing realistic user-journey scenarios, choosing a load injection pattern (ramp-up, spike, or stress), parameterizing tests with feeders, testing WebSocket endpoints, or setting performance assertions and CI throttling.

It is not a fit for functional or UI testing - Gatling and this skill are scoped to load and performance testing via HTTP/WebSocket/JMS protocols, not to browser-driven functional test assertions.

Inputs are the endpoints or user journeys you need to load test and your target performance thresholds. Outputs are working Scala simulation code with protocol configuration, scenario definitions, a chosen load injection strategy, feeders for parameterized data, and performance assertions ready for CI integration.

Performance engineers writing Gatling load tests who need concrete, working simulation templates rather than starting from Gatling's DSL documentation - following eight tips: proper connection-pool resource management, realistic think-time pauses, correlating dynamic tokens and IDs across requests, avoiding sudden load spikes unless deliberately testing for them, monitoring both application and Gatling JVM metrics, isolating test environments, establishing performance baselines before changes, and integrating with Jenkins or GitLab CI via Maven or SBT plugins.