Trending February 2024 # Jasmine Framework Tutorial: Unit Testing With Example # Suggested March 2024 # Top 7 Popular

You are reading the article Jasmine Framework Tutorial: Unit Testing With Example updated in February 2024 on the website Kientrucdochoi.com. We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested March 2024 Jasmine Framework Tutorial: Unit Testing With Example

What is JasmineJS?

Jasmine is an open-source and most popular JavaScript library testing framework to test any kind of JavaScript application. Jasmine follows Behavior Driven Development (BDD) procedure to ensure that each line of JavaScript statement is properly unit tested.

What is the Jasmine Framework Used for?

Testing is a key element to any application. For NodeJS unit testing, the framework available for Testing is called Jasmine. In early 2000, there was a framework for testing JavaScript applications called JsUnit. Later this framework got upgraded and is now known as Jasmine.

Jasmine helps in automated Unit Testing, something which has become quite a key practice when developing and deploying modern-day web applications.

In this Jasmine tutorial, you will learn how to get your environment setup with Jasmine and how to run Jasmine tests for your first chúng tôi application.

In this Jasmine testing tutorial, you will learn-

Jasmine for testing chúng tôi applications

Jasmine is a Behavior Driven Development(BDD) testing framework for JavaScript. It does not rely on browsers, DOM, or any JavaScript framework. Thus, it’s suited for websites, chúng tôi projects, or anywhere that JavaScript can run. To start using Jasmine, you need to first download and install the necessary Jasmine modules.

How to Setup Jasmine Test Environment

Next in this Jasmine Node JS tutorial, you would need to initialize your environment and inspect the jasmine configuration file. The below steps shows how to setup Jasmine in your environment

You need to install jasmine module to use the jasmine framework from within a Node application. To install the jasmine-node module, run the below command.

npm install jasmine-node

Initializing the project – By doing this, jasmine creates a spec directory and configuration json for you. The spec directory is used to store all your test files. By doing this, jasmine will know where all your tests are, and then can execute them accordingly. The JSON file is used to store specific configuration information about jasmine.

To initialize the jasmine environment, run the below command

jasmine init

The configuration file will be stored in the spec/support folder as jasmine.json. This file enumerates the source files and spec files you would like the Jasmine runner to include.

The below screenshot shows a typical example of the chúng tôi file for jasmine.

Note that the spec directory is specified here. As noted earlier, when jasmine runs, it searches for all tests in this directory.

The next thing to note is the spec_files parameter – This denotes that whatever test files are created they should be appended with the ‘spec’ keyword.

Next in this Jasmine framework tutorial, we will learn how to use Jasmine to test chúng tôi applications.

How to use Jasmine to test chúng tôi applications

In order to use Jasmine unit testing for chúng tôi applications, a series of steps need to be followed.

In our example below, we are going to define a module which adds 2 numbers which need to be tested. We will then define a separate code file with the test code and then use jasmine to test the Add function accordingly.

Step 1) Define the code which needs to be tested. We are going to define a function which will add 2 numbers and return the result. This code is going to be written in a file called “Add.js.”

var exports=module.exports={}; exports.AddNumber=function(a,b) { return a+b; }; Code Explanation:

The “exports” keyword is used to ensure that the functionality defined in this file can actually be accessed by other files.

We are then defining a function called ‘AddNumber.’ This function is defined to take 2 parameters, a and b. The function is added to the module “exports” to make the function as a public function that can be accessed by other application modules.

We are finally making our function return the added value of the parameters.

Step 2) Next, we need to define our jasmine test code, which will be used to test our “Add” function In the chúng tôi file. The below code needs to put in a file called add-spec.js.

Note: – The word ‘spec’ needs to be added to the test file so that it can be detected by jasmine.

Code Explanation: var app=require("../Add.js"); describe("Addition",function(){ it("The function should add 2 numbers",function() { var value=app.AddNumber(5,6); expect(value).toBe(11); }); });

We need to first include our chúng tôi file so that we can test the ‘AddNumber’ function in this file.

We are now creating our test module. The first part of the test module is to describe a method which basically gives a name for our test. In this case, the name of our test is “Addition”.

The next bit is to give a description for our test using the ‘it’ method.

We now invoke our Addnumber method and send in 2 parameters 5 and 6. This will be passed to our Addnumber method in the chúng tôi file. The return value is then stored in a variable called value.

The final step is to do the comparison or our actual test. Since we expect the value returned by the Addnumber function to be 11, we define this using the method expect(value).toBe(the expected value).

Output

In order to run the test, one needs to run the command jasmine.

The below screenshot shows that after the jasmine command is run , it will detect that there is a test called chúng tôi and execute that test accordingly. If there are any errors in the test, it will be shown accordingly.

Summary

In order to test a chúng tôi application, the jasmine framework needs to be installed first. This is done by using the Node package manager.

The test code needs to be written in a separate file, and the word ‘spec’ should be appended to the file name. Only if this is done will jasmine be able to detect that a file needs to be run.

To run the test, you need to execute the jasmine command. This will find all files which have the ‘spec’ word attached to it and run the file accordingly.

You're reading Jasmine Framework Tutorial: Unit Testing With Example

Keyword Driven Testing Framework With Example

Keyword Driven Framework

Keyword Driven Framework is a functional automation testing framework that divides test cases into four different parts in order to separate coding from test cases and test steps for better automation. Keyword driven testing framework divides the test cases as test steps, objects of test steps, actions on test steps and data for test objects for better understanding.

What is Keyword Driven Testing?

Keyword Driven Testing is a scripting technique that uses data files to contain the keywords related to the application being tested. These keywords describe the set of actions that is required to perform a specific step.

A keyword-driven test consists of high and low-level keywords, including the keyword arguments, which is composed to describe the action of a test case. It is also called table-driven testing or action word based testing.

For Example:

login to “guru99” website – Keyword “login” will be used in our automation framework, to the test the login function or action associated with it.

logout to “guru99” website— Keyword “logout” will be used in our automation framework, to test the logout function or action associated with it.

We will see some more example further in the article.

Example of keywords

Keywords

Description

Login

Login to guru99 bank demo site

Emails

Send Email

logouts

Log out from guru99 bank demo site

Notifications

Find unread notifications

In order to create a Keyword driven framework, you need following things

Excel Sheet– Identify the keywords and store them in an Excel sheet

Function Library– Function library consist of the function for the business flows ( login button for any website).So when test is executed, it will read the keyword from the Excel sheet and call the functions accordingly

Data Sheets– Data sheets is used to store the test data that will be used in the application

Object Repository– based on your keyword driven framework you can use an object repository

Test Scripts– Based on the design of your framework, you can have test scripts for each manual Test Case or a single driver script

Why do Keyword Driven Testing

In Software Engineering, Keyword Driven Testing is done due to following reason

Common components handled by standard library

Using this approach tests can be written in a more abstract manner

High degree of reusability

The detail of the script is hidden from the users

Users don’t have to use the scripting languages

The test is concise, maintainable and flexible

How to perform Keyword Driven Testing

Keyword based testing can be done in both ways, manually as well as automated. But usually, it is used with automated testing.

The objective behind automating Keyword based testing is

It helps to reduce maintenance cost

Avoids duplicated specifications

Greater reuse of function scripting

Better testing support and portability

Achieve more testing with less or same effort

With keyword driven testing, you can create a simple functional tests in the earlier stages of development, testing the application piece-by-piece. The simplest way to compose keyword driven test is to record them. After recording, the test can be modified and customized as per the requirement.

Each keyword needs to be linked with atleast one command, test scripts or function, which implement the actions related to that keyword.

When test cases are executed, keywords are interpreted by a test library, which is called by a test automation framework.

The major activities involved in keyword driven testing are

Step 1. Identifying low level as well as high-level keywords

Step 2. Implementing the keywords as executable

Step 3. Creating test cases

Step 4. Creating the driver scripts

Step 5. Executing the automation test scripts

Tools used for Keyword Driven Testing

Few tools which are extensively used for Keyword driven testing.

Advantages of Keyword Driven Testing

It allows functional testers to plan test automation before the application is ready

Tests can be developed without programming knowledge

It is not dependent on a specific programming language or tool

Compatible with any automation tools available in the market

Sample test cases

TC_01: Login to guru99 demo site, find out how many transactions is carried out today

TC_02: Login to guru99 demo site, send an email to one of your customer and then logout

TC_03: Login to guru99 demo site and check for any notification received

Summary:

A keyword-driven testing is a scripting technique that uses data files to contain the keywords related to the application being tested

A keyword-driven testing usually performed by automated testing.

Tests can be developed without programming knowledge

Tests are compatible with any automation tools available in the market

What Is Functional Programming? Tutorial With Example

What is Functional Programming?

Functional programming (also called FP) is a way of thinking about software construction by creating pure functions. It avoid concepts of shared state, mutable data observed in Object Oriented Programming.

Functional langauges empazies on expressions and declarations rather than execution of statements. Therefore, unlike other procedures which depend on a local or global state, value output in FP depends only on the arguments passed to the function.

In this tutorial, you will learn-

Characteristics of Functional Programming

Functional programming method focuses on results, not the process

Emphasis is on what is to be computed

Data is immutable

Functional programming Decompose the problem into ‘functions

It is built on the concept of mathematical functions which uses conditional expressions and recursion to do perform the calculation

It does not support iteration like loop statements and conditional statements like If-Else

History of Functional programming

The foundation for Functional Programming is Lambda Calculus. It was developed in the 1930s for the functional application, definition, and recursion

LISP was the first functional programming language. McCarthy designed it in 1960

In the late 70’s researchers at the University of Edinburgh defined the ML(Meta Language)

In the early 80’s Hope language adds algebraic data types for recursion and equational reasoning

In the year 2004 Innovation of Functional language ‘Scala.’

Functional Programming Languages

The objective of any FP language is to mimic the mathematical functions. However, the basic process of computation is different in functional programming.

Here, are some most prominent Functional programming languages:

Haskell

SML

Clojure

Scala

Erlang

Clean

F#

ML/OCaml Lisp / Scheme

XSLT

SQL

Mathematica

Basic Functional Programming Terminology and Concepts

Immutable Data

Immutable Data means that you should easily able to create data structures instead of modifying ones which is already exist.

Referential transparency

Functional programs should perform operations just like as if it is for the first time. So, you will know what may or may not have happened during the program’s execution, and its side effects. In FP term it is called Referential transparency.

Modularity Maintainability

Maintainability is a simple term which means FP programming is easier to maintain as you don’t need to worry about accidentally changing anything outside the given function.

First-class function

‘First-class function’ is a definition, attributed to programming language entities that have no restriction on their use. Therefore, first-class functions can appear anywhere in the program.

Closure

The closure is an inner function which can access variables of parent function’s, even after the parent function has executed.

Higher-order functions

Higher-order functions either take other functions as arguments or return them as results.

Higher-order functions allow partial applications or currying. This technique applies a function to its arguments one at a time, as each application returning a new function which accepts the next argument.

Pure function

A ‘Pure function’ is a function whose inputs are declared as inputs and none of them should be hidden. The outputs are also declared as outputs.

Pure functions act on their parameters. It is not efficient if not returning anything. Moreover, it offers the same output for the given parameters

Example:

Function Pure(a,b) { return a+b; } Impure functions

Impure functions exactly in the opposite of pure. They have hidden inputs or output; it is called impure. Impure functions cannot be used or tested in isolation as they have dependencies.

Example

int z; function notPure(){ z = z+10; } Function Composition

Function composition is combining 2 or more functions to make a new one.

Shared States

Shared states is an importance concept in OOP programming. Basically, It’s adding properties to objects. For example, if a HardDisk is an Object, Storage Capacity and Disk Size can be added as properties.

Side Effects

Side effects are any state changes which occur outside of a called function. The biggest goal of any FP programming language is to minimize side effects, by separating them from the rest of the software code. In FP programming It is vital to take away side effects from the rest of your programming logic.

The benefits of functional programming

Allows you to avoid confusing problems and errors in the code

Easier to test and execute Unit testing and debug FP Code.

Parallel processing and concurrency

Hot code deployment and fault tolerance

Offers better modularity with a shorter code

Increased productivity of the developer

Supports Nested Functions

Functional Constructs like Lazy Map & Lists, etc.

Allows effective use of Lambda Calculus

Limitations of Functional Programming

Functional programming paradigm is not easy, so it is difficult to understand for the beginner

Hard to maintain as many objects evolve during the coding

Needs lots of mocking and extensive environmental setup

Re-use is very complicated and needs constantly refactoring

Objects may not represent the problem correctly

Functional Programming vs. Object-oriented Programming

Functional Programming OOP

FP uses Immutable data. OOP uses Mutable data.

Follows Declarative Programming based Model. Follows Imperative Programming Model.

What it focuses is on: “What you are doing. in the programme.” What it focuses is on “How you are doing your programming.”

Supports Parallel Programming. No supports for Parallel Programming.

Its functions have no-side effects. Method can produce many side effects.

Flow Control is performed using function calls & function calls with recursion. Flow control process is conducted using loops and conditional statements.

Execution order of statements is not very important. Execution order of statements is important.

Supports both “Abstraction over Data” and “Abstraction over Behavior.” Supports only “Abstraction over Data”.

Conclusion

Functional programming or FP is a way of thinking about software construction based on some fundamental defining principles

Functional programming concepts focuses on results, not the process

The objective of any FP language is to mimic the mathematical functions

Some most prominent Functional programming languages: 1)Haskell 2)SM 3) Clojure 4) Scala 5) Erlang 6) Clean

A ‘Pure function’ is a function whose inputs are declared as inputs and none of them should be hidden. The outputs are also declared as outputs.

Immutable Data means that you should easily able to create data structures instead of modifying ones which is already exist

Allows you to avoid confusing problems and errors in the code

Functional code is not easy, so it is difficult to understand for the beginner

FP uses Immutable data while OOP uses Mutable data

Modules Of Surefire Testing Framework

Introduction to Maven Surefire

Apache Maven is a building tool that also supports other operations for project management such as dependency management, documentation and unit testing. The build lifecycle of the maven is divided into multiple phases namely validate, compile, test, package, verify, install, and deploy. Maven surefire is a plugin that is used in the test phase of the build lifecycle of maven. This plugin helps in making the execution of unit test cases of a maven project or application and generate the reports of the testing results in the test phase of the build lifecycle. This plugin creates the reports in two different formats namely plain test files with .txt extension and XML files with .xml extension.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Modules of Surefire Testing Framework

Given below are the various modules framework:

SureFire Logger

SureFire API

Surefire Extensions

SureFireBooter

Maven Surefire Test-Grouping Support

SureFire Providers

ShadeFire JUnit3 Provider

Maven Surefire Common

Surefire Report Parser

Maven Surefire Plugin

Maven Failsafe Plugin

Maven Surefire Report Plugin

Maven Surefire Integration Tests

Surefire Shared Utils

Prerequisites

Maven 3.1.0 or above maven 3.x version.

JDK (Java Development Toolkit) with version 1.7 or higher.

Behavior

The surefire plugins help to export the reports of unit testing in plain text or XML format.

It can also be exported in HTML by taking some extra efforts.

The default path where the generated reports of surefire plugin are stored is /target/surefire-reports/AnyNameOfFile-*(.xml/.txt).

This surefire plugin has one goal defined for it that is surefire, test that specifies to run the unit tests of the maven project/application.

Compatibility with Different Test Providers

Maven surefire plugin works completely fine with any of the following combinations of the test source directories content.

Junit(5.x,3.8 or 4.x version)

POJO(Plain Old Java Object)

TestNG

There is no need for any extra configurations to specify which provider is used and available for the test cases in the maven project. This is incurred from the dependencies that you add in your chúng tôi file.

For example, if you are using Junit 5 for testing, then there will be a dependency tag with JUnit 5 ‘s group id artifact id and version in the dependencies element of your chúng tôi file of the project.

How to use?

One of the most commonly used and preferred methods of using this plugin is to specify the version of this plugin in the plugins element of your chúng tôi file or parent chúng tôi file of your maven project.

Code:

This plugin tag should be added in plugins elements inside the pluginManagement tag of your chúng tôi 3.0.0-M4 is the latest version of the surefire plugin.

An alternative way to use the maven surefire plugin is to call the test phase of the maven builds lifecycle which will invoke this plugin automatically. The test phase of maven lifecycle of building a project can be called by using the following command:

Code:

mvn test

The surefire maven plugin includes all the test classes that are public and contain the word test in it whether the test word be situated in beginning or ending of the class name. However, this behavior can be changed with the help of excludes and includes parameters in configuration in the following way.

Code:

This will lead to exclusion of SampleTest file for unit testing and will include NeedToVerify class file for unit testing even when it does not contains the test word in its name because it was mentioned in include element of configuration element in chúng tôi file.

Example of Maven Surefire

Given below is the example mentioned:

Begin by creating a new maven project.

Consider the following example where we have two methods, one for calculating product and other for division in the class named Arithmetic. Create a new java class file named Arithmetic.

public class Arithmetic { public intproduct(int number1, int number2) { return number1 * number2; } public intdivision(int number1, int number2) { return number1 / number2; } }

This class file should be structured and located in the following way.

Now, we will create a test class named ArithmeticTest according to coding conventions the name of the testing class should be the name of the class which is being tested followed by the Test keyword. This will contain test methods whose naming convention is the name of the method being test prepended with test word. Hence, here are two testing methods named testProduct and testDivision.

Then select the methods you want to add in the test class file and mention the name of the test class file and the file being tested in the following window to create a test class file.

Code:

import org.junit.*; public class ArithmeticTest { @BeforeClass public static void setUpClass() { } @Before public void setUp() { } @Test public void testProduct() { Arithmetic arithmetic = new Arithmetic(); int number1 = 100; int number2 = 5; intactualvalue = arithmetic.product(number1, number2); intexpectedvalue = 500; assertEquals(expectedvalue, actualvalue); } @Test public void testDivision() { } @After public void tearDown() { } @AfterClass public static void tearDownClass() { } }

Note that all the methods above that are annotated with BeforeClass, Before, After and AfterClass are optional. Only test methods are required in test classes. Each method has its specific purpose and the time when it is executed.

Maven’s chúng tôi will contain.

Code:

This file should be structured and present in the following way.

Conclusion

We can test the maven projects with the help of surefire plugin and we can perform unit testing for multiple test cases and with any of the underlying source directories content like Junit, POJO(Plain Old Java Object), TestNG.

Recommended Articles

We hope that this EDUCBA information on “Maven Surefire” was beneficial to you. You can view EDUCBA’s recommended articles for more information.

Testing Login Page Using Robot Framework

Testing Login Page Using Robot Framework

With Robot Framework, we have learnt the following so far −

Import Libraries

Working with variables

Create custom Keywords

How to write test-cases

How to create Setup and teardown

How to execute test cases

How to work with data driven test-cases

We will use all of the above features and use it to test login page in this chapter. We have a login page which takes in email-id and password. When you enter correct email id and password, you will be redirected to a welcome page. If the user enters invalid email id or password, the page will get redirected to error page.

The following screenshot shows a login page −

HTML Code function wsSubmit() { } else { } }

The following screen appears when either the email-id or the password is not valid −

HTML Code

The following screen appears when both the email id and password are valid −

HTML Code

Now we are going to write test cases for the above test page. To start with it, we will first run the command to open Ride.

Command ride.py

Once done, we will get started with the project setup as shown below −

We will save the type of the project as Directory. The name given to the project is testlogin.

Now, we will create test suite inside the project.

Import Library in the main project and also to the test suite created.

Once the library is saved for the project, it will display the library in the settings −

Repeat the same step for the Test suite created.

Here is the library added for Test suite −

Now in the main Project, we will create a setup and teardown. We would like to open the login page in Chrome browser and maximize the window. In teardown, we will close the browser.

For setup, we will create a user−defined keyword called Open Login Page. This keyword will take 2 arguments, login page URL and browser name.

Now, we need 2 scalar variables that will help us store the values – url and the browser name.

In ride, create 2 variables ${loginpage} and ${browser} as follows −

${loginpage}

${browser}

Save both variables.

The variables will be displayed under your project as follows −

Now, we will add the setup and teardown for the main project.

We have created setup that is using user keyword Open Login Page with arguments ${loginpage} and ${browser}.

Now, we have to create the user−defined keyword Open Login Page, which is done as follows −

Now we need to enter the library keywords, which will open the URL.

Open Login Page user−defined keyword has the following details −

*** Keywords *** Open Login Page [Arguments] ${loginpage} ${browser} Open Browser ${loginpage} ${browser} Maximize Browser Window Title Should Be Login Page

Now, we will create Suite Teardown for the suite.

Let us now create a setup for the test suite – Test Setup. This setup needs to get executed first.

For the Test Setup, we have created User defined Keyword called Login Page Display, which will take the argument as ${loginpage} as in the above screenshot.

Now, we need to create the user keyword Login Page Display.

New User Keyword will display the screen as shown below −

Let us now enter the keyword we need for the user keyword Login Page Display.

Here we want to go to the loginpage and check if the title of the page matches with the value given.

Now, we will add template to the test suite and create data driven test cases.

You will be directed to the following screen −

Before we create the Test Login keyword, we need some scalar variables. The scalar variables will have the details of the email-id, password, successpage, failurepage, etc.

We will create scalar variables for test suite as follows −

We have created email, password, successpage and failurepage scalar variables as shown in the above screenshot.

The following screenshot shows the keywords entered for Test Login −

Enter Email, Enter Password, Submit Details and Login Should Fail are User Defined Keywords, which are defined as follows −

Enter Email Enter Password Submit Details Login Should Fail

Now, we will write test cases, which will take different email id and password details to the template created.

The following is a list of test cases −

Invalid email id Test case Invalid Password Invalid Email Id and Password Empty Email Id Empty Password Empty Email and Password

Now, we are done with the test cases and can run the same.

Here are the log messages for the test cases −

20241027 18:11:40.353 : INFO : Opening browser 'chrome' to base url ' http://localhost/robotframework/login.html'. 20241027 18:11:45.960 : INFO : Page title is 'Login Page'. Starting test: Testlogin.Testlogin Suite.Invalid EmailId 20241027 18:11:46.169 : INFO : Page title is 'Login Page'. 20241027 18:11:46.706 : INFO : Typing text 'admin' into text field 'passwd'. 20241027 18:11:47.584 : INFO : Page title is 'Login Failed'. Ending test: Testlogin.Testlogin Suite.Invalid EmailId Starting test: Testlogin.Testlogin Suite.Invalid Password 20241027 18:11:47.767 : INFO : Page title is 'Login Page'. 20241027 18:11:48.342 : INFO : Typing text 'invalid' into text field 'passwd'. 20241027 18:11:49.051 : INFO : Page title is 'Login Failed'. Ending test: Testlogin.Testlogin Suite.Invalid Password Starting test: Testlogin.Testlogin Suite.Invalid EmailId And Password 20241027 18:11:49.213 : INFO : Page title is 'Login Page'. 20241027 18:11:49.221 : INFO : Typing text 'invalid' into text field 'email'. 20241027 18:11:49.555 : INFO : Typing text 'invalid' into text field 'passwd'. 20241027 18:11:50.176 : INFO : Page title is 'Login Failed'. Ending test: Testlogin.Testlogin Suite.Invalid EmailId And Password Starting test: Testlogin.Testlogin Suite.Empty Emailid 20241027 18:11:50.302 : INFO : Page title is 'Login Page'. 20241027 18:11:50.306 : INFO : Typing text '' into text field 'email'. 20241027 18:11:50.486 : INFO : Typing text 'admin' into text field 'passwd'. 20241027 18:11:50.958 : INFO : Page title is 'Login Failed'. Ending test: Testlogin.Testlogin Suite.Empty Emailid Starting test: Testlogin.Testlogin Suite.Empty Password 20241027 18:11:51.063 : INFO : Page title is 'Login Page'. 20241027 18:11:51.367 : INFO : Typing text '' into text field 'passwd'. 20241027 18:11:51.808 : INFO : Page title is 'Login Failed'. Ending test: Testlogin.Testlogin Suite.Empty Password Starting test: Testlogin.Testlogin Suite.Empty Email And Password 20241027 18:11:51.908 : INFO : Page title is 'Login Page'. 20241027 18:11:51.916 : INFO : Typing text '' into text field 'email'. 20241027 18:11:52.049 : INFO : Typing text '' into text field 'passwd'. 20241027 18:11:52.432 : INFO : Page title is 'Login Failed'. Ending test: Testlogin.Testlogin Suite.Empty Email And Password Conclusion

We have seen here how to test a login page with different inputs, which will validate if the login is working fine or not. The details of how the execution takes place is given in the log section.

Advertisements

Correlation In Loadrunner With Web_Reg_Save_Param Example

What is Correlation?

Correlation, as the name suggests, is a mechanism of defining a relationship between two variables or entities. A Dictionary defines it as “statistical relation between two or more variables such that systematic changes in the other accompany systematic changes in the value of one variable”.

In this tutorial, we will learn about

Why do we need Correlation?

Let’s understand co-relation with the following scenario.

Consider you are recording a script using LoadRunner.

Client-Server Communication

During Record,the client sends a request to the server to start a session

A Server receives the request and allocates a new session ID ABC

Client stores the session id ABC in the script.

Client start the session with ID ABC and send a request to a server to allow it to record

The Server recognizes the ID ABC and allows the client to record the script

Now, let’s study the client-server communication during replay

During Replay, a client sends a request to the server to start a session

A Server receives the request and allocates a new session ID XYZ

A Client start the session with previously recorded session ID ABC and send request to server to allow it to record

A Server is unable to identify the ID ABC as it was expecting ID XYZ that it has allocated and session fails.

We need a solution, which to capture parse the dynamic value sent at run-time and return this value back to server. Here is how the client-server communication will look like with this solution

During Replay, a client sends a request to the server to start a session

A Server receives the request, and allocates a new session ID ZZZ

A Client parses this new session id ZZZ from the request.

A Client sends a request to start session with id ZZZ

A Server recognizes the ID ZZZ and allows client to replay the script

This is nothing but correlation.

In case of VUGen, correlation is a binding relationship between a response and any preceding request.

There are various situations when a request is based on a previously received response from the server, such as, a Session ID, server date/time which is fetched from server. These values are different every time you run an application or record a script. Obviously, if the execution of script depends upon a value returned by the server, it means you need to find a mechanism where you can “catch” the server response and attach to those requests which server expects. This is typically called Correlation in LoadRunner.

In simple words, the solution by using Correlation is:

Capture output value from a step

Use above captured value to serve as input to all subsequent steps

Correlation is classified into 2 categories in VUGen/LoadRunner:

Automatic correlation

Manual correlation

Automatic Correlation

LoadRunner provides a mechanism to easily perform correlation in automatic fashion.

VUGen will require you to run a recorded script at least two times so it can internally compare the varying values in the server response.

Automatic correlation can be classified into 3 categories:

Auto-Detect Correlation

Rule-Based Correlation

Correlating All Statements

Rule Name When to Use

Auto-detect Correlation Detect and correlate dynamic data for application servers supported by HP LoadRunner

Rule-Based Used when working with a non-supported application server for which the context is known.

Correlate All Helps correlate all dynamic data in blind fashion.

To configure automatic correlation at the time of recording, perform below configuration in Record Time Setting after a script has been recorded.

Below window will open:

from menu and VUGen will regenerate script (without having to record) with new configurations. VUGen will automatically add a required piece of code to handle correlation. We will look at the sample in more detail in Manual Correlation.

Please note, if you perform correlation manually or use automatic correlation, the piece of code will contain exactly same syntax and function.

Steps to auto-correlate a script:

Record a script

Replay script

Identify the values to be correlated

Verify the script by running again. A successful run means successful correlation.

Tip:

Correlation helps run your script with different values

Correlation also reduces the size of your script

Manual Correlation

Manual correlation is about writing code directly into your script to cater for ever-changing values. We can split it into below steps:

Determine the value to capture

Find the right and left text boundaries of the value to capture (WEB)

Find which occurrence of the text boundaries should be used

Add a web_reg_save_param function to the script, above the piece of code which requests the page with the value to capture

Add a parameter name, left boundary, the right boundary, and occurrence to the function

Parameterize the dynamic value in the script every time it occurs

Verify correct execution

web_reg_save_param (" OracleAppJSESSIONID3", "LB/IC=JSESSIONID=", "RB/IC=;", "Ord=l", "Search=headers", "RelFrameId=l", LAST); web_reg_save_param("Siebel_Analytic_ViewState2", "LB/IC=ViewState" value="", "RB/IC="", "Ord=1", "Search=Body", "RelFrameId=l", LAST);

Manual correlation can be done by VUser Comparison. Steps in VUser Comparison method of Correlation can be split as below:

Identify Dynamic values that need to be correlated

Find Servers response containing the Dynamic value

Capture the Dynamic value in a parameter

Replace every occurrence of the Dynamic value with the parameter

Verify Changes

Understanding Web_reg_save_param function

VUGen provides multiple functions or APIs to correlate candidates, including:

web_reg_save_param

web_reg_save_param_ex

web_reg_save_param_regexp

web_reg_save_param_xpath

Here we go with the function details:

web_reg_save_param(Parameter Name , Left Boundary , Right Boundary )

List of Attributes

Convert: The possible values are:

HTML_TO_URL: convert HTML-encoded data to a URL-encoded data format

HTML_TO_TEXT: convert HTML-encoded data to plain text format; this attribute is optional.

Ignore Redirections: If “Ignore Redirections=Yes” is specified and the server response is redirection information (HTTP status code 300-303, 307), the response is not searched. Instead, after receiving a redirection response, the GET request is sent to the redirected location, and the search is performed on the response from that location.

This attribute is optional. The default is “Ignore Redirections=No”.

LB: The left boundary of the parameter or the dynamic data. If you do not specify an LB value, it uses all of the characters from the beginning of the data as a boundary. Boundary parameters are case-sensitive. To further customize the search text, use one or more text flags. This attribute is required. See the Boundary Arguments section.

NOTFOUND: The handling option when a boundary is not found, and an empty string is generated.

“Not found=error”, the default value, causes an error to be raised when a boundary is not found.

“Not found=warning” (“Not found=empty” in earlier versions), does not issue an error. If the boundary is not found, it sets the parameter count to 0 and continues executing the script. The “warning” option is ideal if you want to see if the string was found, but you do not want the script to fail.

Note: If Continue on Error is enabled for the script, then even when NOTFOUND is set to “error”, the script continues when the boundary is not found, but an error message is written to the extended log file.

This attribute is optional as well.

ORD: Indicates the ordinal position or instance of the match. The default instance is 1. If you specify “All,” it saves the parameter values in an array. This attribute is optional.

Note: The use of Instance instead of ORD is supported for backward compatibility, but deprecated.

RB: The right boundary of the parameter or the dynamic data. If you do not specify an RB value, it uses all of the characters until the end of the data as a boundary. Boundary parameters are case-sensitive. To further customize the search text, use one or more text flags. This attribute is required. See the Boundary Arguments section.

Note: RelFrameID is not supported in GUI level scripts.

SaveLen: The length of a sub-string of the found value, from the specified offset, to save to the parameter. This attribute is optional. The default is -1, indicating to save to the end of the string.

SaveOffset: The offset of a sub-string of the found value, to save to the parameter. The offset value must be non-negative. The default is 0. This attribute is optional.

Search: The scope of the search-where to search for the delimited data. The possible values are Headers (Search only the headers), Body (search only body data, not headers), No resource (search only the HTML body, excluding all headers and resources), or ALL (search body, headers, and resources). The default value is ALL. This attribute is optional but generally preferred.

Update the detailed information about Jasmine Framework Tutorial: Unit Testing With Example on the Kientrucdochoi.com website. We hope the article's content will meet your needs, and we will regularly update the information to provide you with the fastest and most accurate information. Have a great day!