Adding Parameter Options and Dynamic Responses to Transactions

Transactions in the Asset Catalog support the use of parameter options to allow for more dynamic, realistic response data. You can reference values in a Transaction request to ensure that they are repeated appropriately in the response body. For example, if your Transaction is requesting a name, you can configure the response to return a random name.

There are two important components to a creating dynamic responses:

• The parameters that control which data is returned, often based on request values
• Helpers that control the format of the returned data

For a list of supported helpers, see Supported Helper Functions.

There are two ways that you can add dynamic responses to a Transaction:

• Import Transactions with Dynamic Responses from WireMock or RR pairs
• Add Dynamic Responses manually

Import Transactions with Dynamic Responses

BlazeMeter supports preserving dynamic data from imported WireMock Transactions. WireMock uses Handlebar helper functions to dynamically generate responses, and BlazeMeter supports those functions. WireMock uses {{...}} notation, while BlazeMeter uses ${...} notation; however, BlazeMeter automatically adjusts the WireMock notation during import.

BlazeMeter also supports dynamic responses from imported RR pairs, as long as they use the supported ${...} notation.

For other source formats, like HAR, Swagger, and WSDL, import with dynamic responses data is not supported.

Add Dynamic Responses to a Transaction

When you add dynamic responses to an imported or manually created Transaction, you enrich the response data with information from the request. The referenced information can be either in a query parameter, the request header, a request cookie, or the request body.

Follow these steps:

1. Open a Transaction in the Asset Catalog.
2. Examine the Request data for potential values you want to parameterize and return in the response.
3. Edit the Response Body to reference these values.
   All dynamic responses must be contained within ${...} notation. For more information, see Dynamic Response Examples.
   If you want to see a static response with a dollar curly bracket symbol (like ${XYZ}), use the backslash as an escape symbol in the response. For example, if you want to display the response ${xyz} at runtime, use the syntax \${xyz} in the Transaction's response body.
4. To return values in the response based on request data, use one of the following helpers:
   request.query.<parametername>
   Returns the value of the specified query parameter.
   request.headers.<headername>
   Returns the value of the specified header. Within the response header, we are only evaluating the Value section. The Name in the header is not part of the dynamic response.
   request.cookies.<cookieid>
   Returns the value of the specified cookie.
   request.body
   Returns the full request body.
   Other helpers are available to configure formatting, conditional responses, numeric data, and more. For a list of all available Helpers, see Supported Helper Functions.
5. Save the Transaction.

You can give certain parameters random values, while others can return an exact value from the request. For example, if a request is asking to create a user account, you can configure the response to return the requested data in the response.

Dynamic Response Examples

Here are a few simple examples of dynamic response usage:

Return Request Query Parameter Values

Consider a marketing system with lead information. You want to return records matching a specific type of lead.

This Transaction looks up leads with a status of HOT:

http://localhost:64755/leads?status=HOT

The following Transaction response configuration will return response information with the desired status:

This configuration sets the status value to whatever you specify in the Transaction. Using this configuration, the original Transaction would return the following data:

Return Request Header Values

This example uses the Accept request header to send either a JSON or XML response based on the response time:

${#assign "mediaType"}${request.headers.Accept}${/assign}
${#eq mediaType 'application/json'}
{
  "users":[
    {
      "id":1,
      "name":"Mario Speedwagon",
      "status":"${request.query.status}"
    },
    {
      "id":2,
      "name":"Petey Cruiser",
      "status":"${request.query.status}"
    },
    {
      "id":3,
      "name":"Anna Sthesia",
      "status":"${request.query.status}"
    }
  ]
}
${/eq}
${#eq mediaType 'application/xml'}
<?xml version="1.0" encoding="UTF-8"?>
<root>
   <users>
      <id>1</id>
      <name>Mario Speedwagon</name>
      <status>${request.query.status}</status>
   </users>
   <users>
      <id>2</id>
      <name>Petey Cruiser</name>
      <status>${request.query.status}</status>
   </users>
   <users>
      <id>3</id>
      <name>Anna Sthesia</name>
      <status>${request.query.status}</status>
   </users>
</root>
${/eq}

Consider the following example Transaction:

https://mockservicejan3130547pm839-8080-default.mock-new.blazemeter.com/leads?status=HOT

With the dynamic response data entered into the Transaction, it will return a value of HOT for the status and return the data in XML or JSON depending on the Accept header value in the request.

Here is the response to the example Transaction with an application/xml Accept header value:

<?xml version="1.0" encoding="UTF-8"?>
<root>
   <users>
      <id>1</id>
      <name>Mario Speedwagon</name>
      <status>HOT</status>
   </users>
   <users>
      <id>2</id>
      <name>Petey Cruiser</name>
      <status>HOT</status>
   </users>
   <users>
      <id>3</id>
      <name>Anna Sthesia</name>
      <status>HOT</status>
   </users>
</root>

Here is the response to the example Transaction with an application/json Accept header value:

{
  "users":[
    {
      "id":1,
      "name":"Mario Speedwagon",
      "status":"HOT"
    },
    {
      "id":2,
      "name":"Petey Cruiser",
      "status":"HOT"
    },
    {
      "id":3,
      "name":"Anna Sthesia",
      "status":"HOT"
    }
  ]
}

User Name Lookup - GET Request

This Transaction looks up a user name based on an ID number:

curl -X GET "https://contactapp.example.io/contact/1567" -H "accept: application/json"

While you may have recorded a few responses, you might also want a Transaction that returns realistic data when the other Transactions with recorded data are not matched.

The Request URL in BlazeMeter would look like this:

/contact/.*

To return a realistic ID and name value in the response, you would add the following to the Response Body:

The request.path entry tells the response to use the first value in the request path as the value for the id parameter.

For the firstName parameter, the dynamic response creates a random alphabetic value of ten characters.

Account Creation - POST Request

This Transaction creates an account using a POST request with the required account data:

curl -X POST "https://contactapp.example.io/contact" -H "accept: application/json" -H "Content-Type: application/x-www-form-urlencoded" -d "firstName=John&lastName=Doe&phone=(999)-999-9999"

You want the response to return the requested data in the following format:

{
 "id" : 3461,
 "firstName" : "John" //The first letter should be capital
 "lastName" : "DOE" //The whole string should be in upper case
 "phone" : "(XXX)-XX-9999" // Only the last 4 digits needs to be visible
}

Here is how you would format the Transaction response body:

The inputForm argument specifically references the parameters from the request. Each of the three parameters also includes a helper that puts the output in the desired format.

Supported Helper Functions

Helpers let you control the format, appearance, and other factors related to the output date of a dynamic response. BlazeMeter supports the following helpers:

Request Helpers

${request.query.status}

${request.header.Accept}

${request.cookies.JSESSIONID}

${request.body}

String Helpers

Number Helpers

Conditional Helpers

Assign Helpers

WireMock Helpers

BlazeMeter supports WireMock helpers to support import from open source. By default, these helpers use {{...}} in WireMock. BlazeMeter automatically fixes imported Transactions to use the supported ${...} notation, but if you are manually adding these to a Transaction, use the proper BlazeMeter supported notation for them to work.

BlazeMeter supports the following WireMock helpers:

• xPath
• soapXPath
• jsonPath
• randomValue
• hostname
• date
• now
• parseDate
• trim
• base64
• urlEncode
• formData
• regexExtract
• size

For more information about these helpers, see wiremock.org/docs/response-templating.