Load Test Correlation

Detailed explanation

Load test correlation is a crucial step in creating realistic and effective load tests. When recording user actions to create load test scripts, the recorded scripts often contain hardcoded, dynamic values that change with each user session. These values might include session IDs, timestamps, unique identifiers, or other data that is specific to a particular user or session. If these values are not properly handled, the load test will not accurately simulate real user behavior and will likely produce misleading results.

Without correlation, all virtual users in a load test would be sending the same hardcoded values, which can lead to several problems:

• Server-side caching: The server might cache the response to the first request with the hardcoded value and return the same cached response to all subsequent requests. This bypasses the actual server processing and skews the performance metrics.
• Invalid sessions: The server might invalidate the session after the first request, causing all subsequent requests to fail.
• Unrealistic load: The server might not be able to handle the large number of requests with the same hardcoded values, leading to inaccurate performance results.

The goal of correlation is to identify these dynamic values and replace them with parameters that are dynamically generated or extracted from server responses during the load test. This ensures that each virtual user sends unique and valid requests, accurately simulating real user behavior.

Identifying Dynamic Values

The first step in correlation is to identify the dynamic values in the recorded scripts. This can be done by comparing multiple recordings of the same user action. The values that change between recordings are likely dynamic and need to be correlated.

Common dynamic values include:

• Session IDs: Unique identifiers assigned to each user session.
• Timestamps: Current date and time.
• Unique IDs: Database keys, order numbers, or other unique identifiers.
• View state: Information about the current state of a web page.
• Cookies: Small pieces of data stored by the browser.

Correlation Techniques

There are two main techniques for correlating dynamic values:

1. Automatic Correlation: Some load testing tools offer automatic correlation features that can automatically identify and correlate dynamic values. These tools typically use pattern recognition and machine learning algorithms to detect dynamic values and suggest correlation rules. While automatic correlation can save time and effort, it is important to review the suggested rules to ensure that they are accurate and appropriate.

2. Manual Correlation: Manual correlation involves manually identifying dynamic values and creating correlation rules. This technique requires a deeper understanding of the application and the underlying protocols. Manual correlation can be more time-consuming than automatic correlation, but it provides more control and accuracy.

Implementing Correlation

The implementation of correlation typically involves the following steps:

1. Identify the dynamic value: Determine the name and location of the dynamic value in the request.
2. Extract the dynamic value: Extract the dynamic value from the server response using a regular expression or other extraction method.
3. Store the dynamic value: Store the extracted value in a parameter.
4. Replace the hardcoded value: Replace the hardcoded value in the request with the parameter.

Here's an example using JMeter:

Suppose you have a recorded request that includes a session ID:

POST /login HTTP/1.1
...
Cookie: JSESSIONID=ABCD1234567890EFGH
...

The JSESSIONID value changes with each session. To correlate this value, you can use a Regular Expression Extractor in JMeter.

1. Add a Regular Expression Extractor: Add a Regular Expression Extractor as a child of the request that returns the JSESSIONID.
2. Configure the Extractor:
   • Name of created variable: sessionID
   • Regular Expression: JSESSIONID=(.+?);
   • Template: $1$
   • Match No.: 1
   • Default Value: NOT_FOUND
3. Replace the hardcoded value: Replace the hardcoded JSESSIONID value in subsequent requests with the ${sessionID} variable.

POST /nextpage HTTP/1.1
...
Cookie: JSESSIONID=${sessionID};
...

Now, each virtual user will use a unique JSESSIONID value, accurately simulating real user behavior.

Best Practices

• Record multiple scenarios: Record multiple instances of the same scenario to identify dynamic values more accurately.
• Use regular expressions carefully: Regular expressions can be powerful, but they can also be complex and error-prone. Test your regular expressions thoroughly to ensure that they extract the correct values.
• Parameterize all dynamic values: Ensure that all dynamic values are properly parameterized to avoid unrealistic test results.
• Use correlation libraries: Some load testing tools provide correlation libraries that can simplify the correlation process.
• Verify correlation: After implementing correlation, verify that the virtual users are sending unique and valid requests.
• Maintain correlation rules: As the application evolves, the dynamic values and correlation rules may change. Regularly review and update the correlation rules to ensure that they remain accurate.

Common Tools

Popular load testing tools that support correlation include:

• JMeter: A free and open-source load testing tool with powerful correlation capabilities.
• LoadRunner: A commercial load testing tool with advanced correlation features.
• Gatling: An open-source load testing tool with a focus on performance and scalability.
• NeoLoad: A commercial load testing tool with a user-friendly interface and advanced correlation features.

By properly implementing load test correlation, you can create realistic and effective load tests that accurately simulate real user behavior and provide valuable insights into the performance and scalability of your application. This ensures that your application can handle the expected load and provide a positive user experience.

Further reading

• JMeter Correlation
• LoadRunner Correlation
• Gatling documentation