Reguar Expressiion extractor in Jmeter to understand ORD ALL scenarion in LoadRunner

 Using RegEx (Regular Expression Extractor) with JMeter

Jacob Sharir

JMeter, the most popular open source performance testing tool, can work with regular expressions, with the Regular Expression Extractor. Regular expressions are a tool used to extract a required part of the text by using advanced manipulations. Regular expressions are popular when testing web applications because they can be used to validate and to perform operations on a response from a web application.

In JMeter, the Regular Expression Extractor is useful for extracting information from the response. For example, when you request a page and then need to get a link from the page that was downloaded. Another use case is saving the extracted information to a variable, so it can be used later on in the performance test, for example when testing an application that uses token authentication, like CSRF/XSRF.

In this article I’m going to share how to use the Regular Expression Extractor in JMeter.

I created a very simple test-plan, look at Figure 1:

Figure 1

 

You may notice one unknown element in the image; it is the Regular Expression Extractor post-processor. Let's look at it more closely, in Figure 2:

Figure 2

 

Regular Expression Extractor Syntax

When configuring the regular expressions in JMeter, use the same syntax as Perl5. But there is one very important difference between JMeter and Perl regexps processing. In Perl you have to use the “//” delimiter to specify regexp. So, the regular expressions reg might appear like this: ~/regular_expression/. But you cannot use “//” for the same purpose in JMeter, otherwise the regular expression will be parsed literally, and not logically. So, if you are using grouping in a regular expression, use the “()” parentheses to separate one group from another.

 

Configuring the Regular Expression Extractor

Now I will shortly describe all of this element's fields.

“Apply to” radio button

You can choose whether the regular expression will be applied to the main sample results, to the sub-samples/embedded resources, or both.

The possible options are:

• Main sample only - only applies to the main sample
• Sub-samples only - only applies to the sub-samples
• Main sample and sub-samples - applies to both main sample and sub-samples
• JMeter Variable - the expression is applied to the filled in variable

“Field to check” radio button

You can choose which field the regular expression is applied to. The possible options are:

• Body - the body of the response. The content of your web-page, excluding headers, will be parsed with the regular expression.
• Body (unescaped) - the body of the response, with all HTML escape codes replaced. Note that HTML escapes are processed without regard to context, so some incorrect substitutions may be made.
• Headers - the headers of the response or the request
• URL – the URL of the request
• Response Code - e.g. 200
• Response Message - e.g. OK

Name of Created Variable - the name of the variable where the parsing results will be saved in JMeter.

Regular Expression - fill in the regular expression to test.

Template - choose the group you would like to extract from the regular expression. '$1$' will extract group 1, '$2$' will extract group 2, and so on. $0$ will extract the entire expression. For example, if you have the word “economics” in your response and you search for the regular expression “(ec)(onomics)” and apply template $2$$1$, then in the output variable you will receive “onomicsec”. If you apply template $0$, then in the output variable you will receive "economics".

Match ¹. If there is several character sequences, allows specifying, which variant exactly should be used. Important note. If you set “Apply to” to “Main sample and sub-samples” and specify “Match ¹” = 3, than JMeter will select matching sequence from the 2nd sub-sample because 1st will be main sample. If zero is specified, JMeter will choose a match at random. If you specify negative number, e.g. “-2”

If the match number is set to a negative number, then all the possible matches in the sampler data are processed. The variables are set as follows:

refName_matchNr - the number of matches found; could be 0

refName_n, where n = 1,2,3 etc - the strings as generated by the template

refName_n_gm, where m=0,1,2 - the groups for match n

refName - always set to the default value

refName_gn - not set

Indicates which match to use. The regular expression may match multiple times.

Use a value of zero to indicate JMeter should choose a match at random.

A positive number N means to select the nth match.

That’s all about options of Regular Expression Extractor. And now I will show a couple of practical examples. In all examples I will use the same URL for extracting string by regexp, see Figure 3.

Figure 3

 

After extracting string it will be put to variable $pageLink and used in “pageLink” HTTP Request as it displayed in Figure 4.

Figure 4

 

Searching by word. If you need to extract string with regular expression that is a single word than fill Regular Extractor as in Figure 5.

Figure 5

 

After executing “tut.by” request and extracting regexp, we will get the following $pageLink = economics, and that will be used in “pageLink” request, Figure 6.

Figure 6

 

Using groups. You can move parts of regular expressions using groups. For example, you need to find word “economics”, but before putting it to $pageLink you want to rearrange parts of word. Look at the Figure 7 for the syntax

Figure 7

 

And what we’ll have in View Results Tree

Figure 8

 

Using classes in regexps. Regular expressions can use classes of characters. For example, [0-9] means “any of numeric symbol ”. If I set regexp as in Figure 9, than I will receive the 3rd appropriate result from response body.

Figure 9

 

“{5,6}” means that result should contain no less then 5 and no more then 6 characters. And what we will have in View Results Tree in Figure 10

Figure 10

 

Using “^”. “^” means inversion, e.g. regular expression [^0-9] will look for non-numeric symbols. So, I’ll set regexp as in Figure 11

Figure 11

 

And in View results Tree I will have very interesting situation, Figure 12

Figure 12

 

What happened? Look at Figure 13

Figure 13

 

We caught “carriage return” symbol and this is a reason of java.net.MalformedURLException. To repair regexp I’ll add “<” before it and restart test. Now it’s ok.

Figure 14

 

Of course, I cannot cover in one article all possible and impossible cases about using regular expressions. For more information you can refer to JMeter Regular Expressions Tutorial which has exhaustive information.

JMeter uses Jakarta ORO for regular expressions processing. You can quickly test your regular expressions using Jakarta ORO Demonstration Applet which is the fastest way of seeing result matches/groups/etc.

How to convert SAZ fiddler file to JMX file

 I was not able to open SAZ file directly into Jmeter, followed below steps:

First we have to convert SAZ file to HAR file

To convert a SAZ file to a .Jmx file:

• Double-click on the saved SAZ file, it should open Fiddler. Install Fiddler from Fiddler Download Page if necessary,
• Click on File > Export > All Sessions > HTTP Archive 1.2.
• Save HAR file
• Go to https://converter.blazemeter.com/ , upload your HAR file on the site , it will convert it into JMX.
• Open same JMX in your Jmeter.

how to integrate HP Loadrunner with Jenkins

Jenkins HP Application Automation Tools add-in

I knew that this Jenkins plugin worked with ALM and QTP/UFT but it was new to me that is also works with HP LoadRunner 11.52. This add-in allows you to enable a trigger for a LoadRunner Scenarios as a build step, and its results will show up in the Jenkins results dashboard.

Jenkins Setup

To start using the HP Application Automation Tools with LoadRunner you need to do the following setup work in Jenkins:

First install the Jenkins HP Application Automation Tools add-in

1) In your Jenkins instance, navigate to the Manage Jenkins area and click on the Manage Plugins link.

2) Click on the Available Tab.

3) Under the Filter text box, enter HP.

4) Under the Available tab, look for the name HP Application Automation Tools.

5) Click on the Install checkbox and click on the Download Now and Install After
Restart button.

Configure Jenkins

Once the add-in is installed and you have restarted Jenkins:

1. Click on the Jenkins>New Job menu option. 
   
2. Enter a Job Name – I named my RunLoadrunner – and click on the Build a free-style software project option. Click OK
   
   
   
3. Under the your new project’s configuration scroll down to the Build section and click on the Add build step and click on the Execute HP tests from file system option
   
   
4. Under Build you should now have an option for LoadRunner-Specific Settings.. – Click on it.
   
   
5. Under the LoadRunner Settings enter the following:
   

• Controller Polling Interval – the time to poll the LR Controller for your scenario status
• Scenario Execution Timeout – this is the total time for the execution of all your scenarios
• Errors to Ignore – – during the run you can tell which errors to ignore

1. Under the Build/Tests section enter the path to your LoadRunner scenario. For example my scenario named JnekinsDebug.lrs lives under my D:\myLoadRuner directory. So my Tests field =D:\myLoadRunner
   
   
2. Under the Post-build Actions section click on the Add post-build action and select Publish HP tests result
   
   
3. Apply and Save your settings
4. Run the LR job you just created like you would any standard Jenkins job

Set LoadRunner Scenario SLA

One thing to watch out for is to make sure that your scenario has a SLA defined. If it does not your Jenkins job will fail with a message similar to this:

To fix just go into your Scenario in the LoadRunner Controller and add a SLA:

LR Jenkins CI Wrap-up

That is how you integrate LoadRunner with Jenkins. Hope it helps. Let me know if I missed anything.

Ajax TruClient End events

Ajax truclient end event:

During the second script replay, TruClient confirm the Automatic End Event and will assigned any step's End Event that had been reset to Automatic: Not Set Yet.

If TruClient is unable to assign an automatic End Event during replay, usually due to a network timeout, a warning message will inform you that the End Event has been reset to Automatic: Not Set Yet. Replay the script to automatically assign the End Event or assign the End Event manually.

identifying the end event

Before enhancing an Ajax TruClient script, replay the script to synchronize the steps. During the first script replay, TruClient will try to automatically identify the End Event for each step.

An End Event can be one of the following:

• Action Started - Dispatched when the action defined in the step is starting. For steps with objects (i.e. most steps) it will occur right after the object has been successfully found in the application.
  
 • Action Completed - Dispatched when the action defined in the step is completed. 
 
 • Step network completed - Dispatched when the network activity associated with the step is completed. Ajax TruClient waits a small amount of time in order to make sure that no new requests are created after all other requests have ended. The threshold is configurable via the script Runtime Settings (default is 150ms). 
 
 • DOM Content Loaded - Corresponds to the "domcontentloaded" event and is dispatched when parsing of the page is completed. The event will be dispatched only if the step's action has triggered a page navigation.
 
 • Document Loaded - Corresponds to the standard "load" event and is dispatched when the page is completely loaded, including frames/images/stylesheets. The event will be dispatched only if the step's action has triggered a page navigation. 
 
 • Dialog opened - A modal dialog has opened. The dialog can either be opened from JavaScript (using the alert/confirm/prompt functions) or is an authentication dialog.

Important links on Ajax truclient :

http://claudihome.com/html/LR/WebHelp/Content/VuGen/TruClient/125700_ajax_TC_functions.htm

https://community.hpe.com/t5/LoadRunner-Practitioners-Forum/VUGen-Ajax-TruClient-Evaluate-JS-on-Object/td-p/2392313

https://community.hpe.com/hpeb/attachments/hpeb/sws-LoadRunner_SF/6769/1/LoadRunner11.00_AjaxTruClient_TipsTricks.pdf

Difference between Application server and Web server ?

A Web server exclusively handles HTTP requests, whereas an application server serves business logic to application programs through any number of protocols.

The Web server:
A Web server handles the HTTP protocol. When the Web server receives an HTTP request, it responds with an HTTP response, such as sending back an HTML page. To process a request, a Web server may respond with a static HTML page or image, send a redirect, or delegate the dynamic response generation to some other program such as CGI scripts, JSPs (JavaServer Pages), servlets, ASPs (Active Server Pages), server-side JavaScripts, or some other server-side technology. Whatever their purpose, such server-side programs generate a response, most often in HTML, for viewing in a Web browser. 

Understand that a Web server's delegation model is fairly simple. When a request comes into the Web server, the Web server simply passes the request to the program best able to handle it. The Web server doesn't provide any functionality beyond simply providing an environment in which the server-side program can execute and pass back the generated responses. The server-side program usually provides for itself such functions as transaction processing, database connectivity, and messaging. 

While a Web server may not itself support transactions or database connection pooling, it may employ various strategies for fault tolerance and scalability such as load balancing, caching, and clustering—features oftentimes erroneously assigned as features reserved only for application servers. 

The application server:
As for the application server, an application server exposes business logic to client applications through various protocols, possibly including HTTP. While a Web server mainly deals with sending HTML for display in a Web browser, an application server provides access to business logic for use by client application programs. The application program can use this logic just as it would call a method on an object (or a function in the procedural world). 

Such application server clients can include GUIs (graphical user interface) running on a PC, a Web server, or even other application servers. The information traveling back and forth between an application server and its client is not restricted to simple display markup. Instead, the information is program logic. Since the logic takes the form of data and method calls and not static HTML, the client can employ the exposed business logic however it wants.

In most cases, the server exposes this business logic through a component API, such as the EJB (Enterprise JavaBean) component model found on J2EE (Java 2 Platform, Enterprise Edition) application servers. Moreover, the application server manages its own resources. Such gate-keeping duties include security, transaction processing, resource pooling, and messaging. Like a Web server, an application server may also employ various scalability and fault-tolerance techniques.

Lets see the below example:

As an example, consider an online store that provides real-time pricing and availability information. Most likely, the site will provide a form with which you can choose a product. When you submit your query, the site performs a lookup and returns the results embedded within an HTML page. The site may implement this functionality in numerous ways. I'll show you one scenario that doesn't use an application server and another that does. Seeing how these scenarios differ will help you to see the application server's function. 

Scenario 1: Web server without an application server
In the first scenario, a Web server alone provides the online store's functionality. The Web server takes your request, then passes it to a server-side program able to handle the request. The server-side program looks up the pricing information from a database or a flat file. Once retrieved, the server-side program uses the information to formulate the HTML response, then the Web server sends it back to your Web browser.
To summarize, a Web server simply processes HTTP requests by responding with HTML pages.

Scenario 2: Web server with an application server
Scenario 2 resembles Scenario 1 in that the Web server still delegates the response generation to a script. However, you can now put the business logic for the pricing lookup onto an application server. With that change, instead of the script knowing how to look up the data and formulate a response, the script can simply call the application server's lookup service. The script can then use the service's result when the script generates its HTML response. 

In this scenario, the application server serves the business logic for looking up a product's pricing information. That functionality doesn't say anything about display or how the client must use the information. Instead, the client and application server send data back and forth. When a client calls the application server's lookup service, the service simply looks up the information and returns it to the client. 

By separating the pricing logic from the HTML response-generating code, the pricing logic becomes far more reusable between applications. A second client, such as a cash register, could also call the same service as a clerk checks out a customer. In contrast, in Scenario 1 the pricing lookup service is not reusable because the information is embedded within the HTML page. To summarize, in Scenario 2's model, the Web server handles HTTP requests by replying with an HTML page while the application server serves application logic by processing pricing and availability requests.

Note:Recently, XML Web services have blurred the line between application servers and Web servers. By passing an XML payload to a Web server, the Web server can now process the data and respond much as application servers have in the past.
Additionally, most application servers also contain a Web server, meaning you can consider a Web server a subset of an application server. While application servers contain Web server functionality, developers rarely deploy application servers in that capacity. Instead, when needed, they often deploy standalone Web servers in tandem with application servers. Such a separation of functionality aids performance (simple Web requests won't impact application server performance), deployment configuration (dedicated Web servers, clustering, and so on), and allows for best-of-breed product selection.

How to handle java script generated Session ID in Vugen using Load runner

A session id (GUID) is generated on client side via a javascript and sent to the server. This cannot be correlated because it doesn’t come from the server.

You will need to figure this out from the page source. In my case, the sessionID is assigned a value of window.SessionId where window.SessionID = NewGuid()

The body of NewGuid() is -

function NewGuid() {
-------

-Creates a new pseudo GUID.
------

var guid = ‘xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx’.replace(/[xy]/g, function (c) {
var r = Math.random() * 16 | 0, v = c == ‘x’ ? r : (r & 0×3 | 0×8);
return v.toString(16);
});
return guid;

}

This generates a session ID like : 3f58555c-d6f4-4b1e-ac2a-b89f5d173944

then Use web_js_run() function.
Save the above javascript code with .js extension in the script folder.
Add the script under Extra files via Add Files option
Go to RunTimeSettings -Preferences-Options-Web Javascript header-Enable running javascript code == change the value to Yes
Write the following function.the the result is stored in param1

Flex Protocol Scripting in LR

Introduction

Adobe Flex is a software development kit released by Adobe Systems for the development and deployment of cross-platform rich Internet applications based on the Adobe Flash platform. Flex applications can be written using Adobe Flex Builderor by using the freely available Flex compiler from Adobe.

Developers use two core languages to create Flex applications. The first core language is MXML, the Macromedia Flex Mark-up Language, which includes a rich set of XML tags that allows developers to layout user interfaces. Some MXML constructs allow you to call remote objects, store data returned in a model, and customize your own look and feel to MXML components.

The second core language for Flex development is Action Script 2.0, which is similar to JavaScript. Action Script elements are coded inside MXML pages has robust event handling capabilities to allow the application to respond to dynamic user interactions. Unlike JavaScript, since Action Script runs inside the Flash plug-in there is no need to rewrite several versions of the same code to support different browsers.

The Flex server is responsible for translating the MXML and Action Script components into Flash byte code in the form of .SWF files. The SWF file is executed on the client in the Flash runtime environment. The Flex server provides other services such as caching, concurrency, and handling remote object requests. 

Flex Protocol with LR

VuGen allows you to create Vusers that emulate the protocol suite provided with the Flex 2 SDK.

RIAs are lightweight online programs that provide users with more dynamic control than with a standard web page. Like Web applications built with AJAX, Flex applications are more responsive, because the application does not need to load a new Web page every time the user takes action. However, unlike working with AJAX, Flex is independent of browser implementations such as JavaScript or CSS. The framework runs on Adobe's cross-platform Flash Player. 

Pre-requisite

•     Load Runner 11.0 support the flex with the patch3
•     JRE 6.0 
•     Adobe flash player 10 and higher

Environment Variables

Verify for the following environment variables in Windows Operating system.

The environment variables can be reached by following the below steps:

1.    Right-click “My Computer”. Go to properties.

2.    Go to Advanced Tab

3.    Click on the Environment Variables button

Click on the “New “button under System variables and enter the below values:

Variable name: HP_FLEX_JAVA_LOG_FILE

Variable value: C:\flex.log

Variable name: VUGEN_PATH

Variable value: C:\Program Files\HP\Virtual User Generator\

Variable name: ANALYSIS_PATH

Variable value: C:\Program Files\HP\LoadRunner\

* The HP_FLEX_JAVA_LOG_FILE is used to generate the log file which will help us to identify the classes involved in a particular transaction.

This log file will be very useful for debugging. Ensure that there are no errors in the flex log file after recording.

Recording Options

The following recording options need to be considered before recording in flex protocol:

·         Go to Tools à Recording Options in LoadRunner.

·         Under Script Check the check box against “Generate recorded event logs”. This setting helps to generate the log files for debugging

·         Under Protocols tab select all three check boxes viz.,

o    Action Message Format (AMF)

o    Flex

o    Web(HTTP/HTML)

·         Under Recording, select HTML based script.

·         Select HTML Advanced button and select “A script that contains explicit URLs only (e.g.web_url, web_submit_data)”  and “Record in separate steps and use concurrent grops” for Non HTML – generated elements

·         Under Code generation select Encode AMF3 using external parser.And provide the below jar files location under Value column.

o    flex-messaging-common.jar

o    flex-messaging-core.jar

o    (Any application specific jars.The jars are dependent on the transaction and should be verified before recording every transaction)  

·         Under Port-Mapping, click on Options. Under Advanced Port Mapping Settings à Change Log level to Advanced Debug. - This setting would enable to generate flex log in C:\ drive.

  

·         The Advanced tab under HTTP properties is the standard one. 

·         Under Correlation tab, uncheck the “Enable correlation during recording” check box.

 

Post Recording Verification

After recording verify following:

1.    A file by name “flex. log” should be generated in C:\ drive.

2.    flex_amf_call should be generated with readable XML’s and not the binary format for all requests.

Correlation in Flex Scripts

Flex applications often contain dynamic data, data that changes each time you run the script. For example, the object name may change from run to run.

When you record a Vuser script, VuGen records a set of data and argument values. When you replay the script, however, the server may reject these arguments and issue an error. This error could be the result of dynamic data that is outdated and no longer accepted by the server.

To overcome this, you apply correlation to your script:

➤ Save the server response in preparation for extracting the required values.

➤ Extract the required values from the server response.

➤ Save the values to a parameter.

➤ Use those parameters as input to your Flex requests.

These errors are not always obvious, and you may only detect them by carefully examining Vuser log files. If you encounter an error when running your Vuser, examine the script at the point where the error occurred. Often, correlation will solve the problem by enabling you to use the results of one statement as input for another.

To perform correlation:

1 Locate the step in your script that failed due to dynamic values that need correlation.

Use the Replay Log to assist you in finding the problematic step.

2 Identify the server response with the correct value in one of the previous steps.

Double-Click the error in the Replay log to go to the step with the error. Examine the preceding steps in Tree View and look for the value in the Server Response tab.

3 Save the entire server response to a parameter.

Before you extract the value, the entire server response should be saved to a parameter as follows:

➤ Right-click the step node (in the left Action pane) corresponding to the server response containing the value and select Properties.

➤ In the Flex Call Properties dialog box, type a Response parameter name.

➤ Click OK to save the new parameter name.

4 Save the original server response value to a parameter.

➤ In the Replay Snapshot: Response Data, right-click the node above the value (for example, string), and select Save value in parameter.

 

In the XML Parameter Properties dialog, specify a parameter Name. You will use this name in subsequent steps.

➤ Click OK. The script will now contain a new function, lr_xml_get_values.

5 Insert the parameter in the subsequent calls.

In VuGen edit view, beginning with the call that failed, replace the value in all subsequent calls to the object with the parameter that you defined:

➤ Right-click the step node (in the Action pane) corresponding to the failed call and select Properties.

➤ Locate the argument that required correlation.

➤ In the Value box, type the parameter name in curly brackets, for example, {ParamValue_string}.

Click OK

 

6 Run the script.

Make sure that VuGen properly substitutes the argument value with the parameter value that you saved.

Some Important JAR files needed are 

 

We need application JAR files as well along with these JAR files from developer to generate the decoded AMF calls in the scripts else we can’t parse and correlate the requests.