Gestione dei valori dinamici (correlazione)

When you interact with a web application, many values in the server's responses aren't static. These are called dynamic values.

They change with each user, session, or even each request. Think of them like temporary keys the server gives you.

• Session IDs
• Authentication Tokens
• CSRF Tokens

If your performance test simply records and replays requests, it often fails. Why?

Because the recorded requests contain old, invalid dynamic values. The server rejects them, thinking you're not a legitimate user or session.

Correlation is the process of extracting these dynamic values from one response and reusing them in subsequent requests.

JMeter provides a powerful tool to handle dynamic values: the Regular Expression Extractor.

This Post-Processor component allows you to define a pattern (a regular expression) to search within a server's response and capture specific data.

It's like telling JMeter: "Find this pattern, and grab whatever is inside these brackets!"

Here's the basic flow for using a Regular Expression Extractor:

1. Send Request: Your JMeter sampler sends a request to the server.
2. Receive Response: The server sends back a response, which contains the dynamic value.
3. Extract Value: The Regular Expression Extractor scans the response for your defined pattern.
4. Store Value: It captures the dynamic data and stores it in a JMeter variable.
5. Reuse Value: You then use this variable in subsequent requests.

A Regular Expression (Regex) is a sequence of characters that defines a search pattern. For extraction, you'll often use:

• . (dot): Matches any single character.
• * (asterisk): Matches zero or more occurrences of the preceding character.
• ? (question mark): Makes the preceding quantifier (like *) non-greedy, matching the smallest possible string.
• () (parentheses): Used to capture the part of the string you want to extract.

Try running this simple JavaScript example to see regex in action:

In JMeter, the Regular Expression Extractor is a Post-Processor. This means it runs after a sampler (request) completes but before the results are recorded.

To add it:

1. Right-click on the HTTP Request (or other sampler) that receives the dynamic value.
2. Go to Add > Post-Processors > Regular Expression Extractor.

It will become a child of that specific request.

The Regular Expression Extractor has several key fields:

• Reference Name: The name of the JMeter variable to store the extracted value (e.g., sessionId).
• Regular Expression: The actual regex pattern to match (e.g., name="sessionId" value="(.+?)").
• Template: How to construct the value. Use $1$ for the first captured group, $2$ for the second, etc.
• Match No.: If multiple matches, which one to use? 0 for random, 1 for first, -1 for all (creates multiple variables).
• Default Value: A value to assign if the regex doesn't find a match.

Once the Regular Expression Extractor stores a value in a variable (e.g., sessionId), you can use it in any subsequent JMeter sampler or component.

To reference the variable, use the syntax ${ReferenceName}.

For example, if you extracted a session ID into sessionId, you might use ${sessionId} in the body or URL path of a follow-up request.

Consider a login sequence:

1. Request 1 (Login): Sends username/password.
2. Response 1: Contains a CSRF_Token in a hidden field.
3. Regex Extractor: Extracts CSRF_Token from Response 1 and stores it in ${csrfToken}.
4. Request 2 (Submit Form): Uses ${csrfToken} in its request body or URL parameters.

This ensures your test script behaves like a real user, passing the dynamic token.

Imagine a server response contains the following HTML snippet:

<input type="hidden" name="token" value="abc123xyz456" />

You want to extract the value abc123xyz456 into a JMeter variable named authToken.

Which Regular Expression and Template combination should you use in the Regular Expression Extractor?

Great job! You've learned the critical skill of correlation in JMeter.

• Dynamic values require special handling to prevent test failures.
• The Regular Expression Extractor is JMeter's primary tool for this.
• You define a regex pattern to capture specific data from server responses.
• Extracted values are stored in JMeter variables for reuse in subsequent requests.

This technique makes your performance tests robust and realistic. Next, we'll explore more JMeter functions and variables for even greater script flexibility!