Selenium: BDD- The Disruptive Framework

As we learnt about different selenium automation framework in last post, now it is time to focus on one particular framework which will shape the future of selenium automation testing and that is nothing but Behavior Driven Development (BDD) framework ! 

BDD serves as a bridge between tech and non-tech people which includes but not limited to developers, testers, clients and business analysts. In BDD, we can write our automation tests in general English like language which can be understand by all the stake holders and eventually it paves the way for smoother functioning and more productive environment. With the coming of agile model, concepts such as BDD has found more meaning and usage. The important feature of BDD is that it includes all the stake holders.

Features of BDD: 
  • Collaboration between developer team, QA team, client and business analysts.
  • It uses plain English like language 'Gherkin' to describe tests.
  • It augments business value by thinking in terms of behavior.
  • It extends TDD by ubiquitous language gherkin which can be understand by non-tech people also. 
  • 'Cucumber' and 'JBehave' are two such popular BDD frameworks.

Feature File:

This is the main component of BDD framework as here we describe our test scenario in gherkin language. It follows some syntax as it is structured language. Generally, we use three main keywords 'Given', 'When' and 'Then' while writing one particular test automation scenario. 

Let us see one example:  

Feature: Login functionality on login page of Application 


Scenario: Verification of login 


Given Open the Firefox and launch the application


When Enter the Username and Password


Then Close the Browser


Steps:

This is the actual class where we write our code.

package StepDefination;

@SuppressWarnings("unused")
public class Steps {

@Given("^Open the Firefox and launch the application$")
    public void open_the_Firefox_and_launch_the_application() throws Throwable
    {
    // need to write code here

}

 @When("^Enter the Username and Password$")
   public void enter_the_Username_and_Password() throws Throwable
    {
      // need to write code here
}

 @Then("^Close the Browser$")
    public void Reset_the_credential() throws Throwable
    {  

     // need to write code here
}

}
 
Here, we are binding our features with the actual code.

Runner:

This one is the class from where we run our scripts.

package TestRunner;

import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;

@RunWith(Cucumber.class)
@CucumberOptions(features="Features",glue={"StepDefination"},monochrome=true)
public class Runner
{

}


This is one demo scenario which is implemented through BDD framework. We will see more such BDD functions and options in coming posts.

Cheers !





Comments

Post a Comment

More posts on selenium...

Selenium/Java-OOPs-Encapsulation

Image
We have started to learn OOPs concepts from last post, starting with Abstraction. In this post, we will go through the concept of Encapsulation.  Encapsulation: Basically, Encapsulation binds data(variables) and code together. It is a process of wrapping up the data in single unit. We declare our variables as private, so it can not be accessed outside the class. Hence, it is also called data hiding approach. However, if you wish to access the variables outside the class, we can use public setter and getter methods to access such private variables.  The first question arises here is, why to declare variables as private if anyway we can use it outside the class using setter and getter methods.. !! That's where the concept of Encapsulation flourishes..!! Here, we are declaring variables as private and hence one can not get the idea about the implementations of the class. User can only surmise that how the variable will be stored (It can be String, integer ...
Read more

Selenium/Java-OOPs-Abstraction

Image
In last post, we learnt about different types of constructors Selenium/Java- CoC  in Java which are important and very useful while writing  Selenium automation scripts. Now we will move towards Java OOPs concepts and in this post we will deal with Abstraction. Abstraction: It is a process of hiding implementation details and showing only functionality to the user. It hides internal details. An abstract class is declared with Abstract keyword. We need to declare class as abstract to use abstract methods. We can not create objects of the Abstract class. Abstract class can have both abstract as well as concrete(normal) methods. It is most useful when two sub-classes are doing same thing in different ways. When we define sub-classes, we use extends keyword to show that it is a child class of parent class. Super keyword is also used in abstraction when we need to use immediate parent class instance variable, method or constructor. Example: // de...
Read more

Selenium: Automate Web Application Login

Image
From last post, we have started writing basic selenium automation scripts. Now, let's take that journey forward and try to automate any web based application.  In this post, we will automate our Facebook login as a demo which can be used for any web based application with little modifications. [Source: www.facebook.com ] Code with Explanation:  We will create one class named FacebookLogin in the package blog in eclipse which we have created during googleSearch automation script. package blog; Here, we will import all the necessary external jars, we can give suppress warnings for jar which we are not using. import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.chrome.ChromeDriver; @SuppressWarnings("unused") public class FacebookLogin {...
Read more

Selenium/Java- CoC

Image
From last post, we started to go through some of the basic concepts of Java which are needed to embark our journey of Selenium. On the same line, let us learn one such very important concept that is nothing but CoC (Concept of Constructor..!). In general, constructor is a code that is used to initialize objects of the class,for more info on class and object, please visit  Selenium with JAVA…  . Specifically, it is one special type of method to pass the value to the object at the time of object creation. Some people say that method and constructor is same in Java but that is not the fact due to following reasons. Hence, I call constructor as one special type of method. Constructor must have same name as of the class which is not the case for methods..! Constructor does not have any return type but method surely does..! Constructor can not be abstract, final or static but method can..!(Relax, we will learn about all the three keywords in coming posts..!!) T...
Read more

Selenium/Java-OOPs-Inheritance

Image
In last posts, we learnt about Abstraction and Encapsulation concepts of OOPs. In this post, we will go through the concept of Inheritance. Inheritance allows object of one class to acquire properties and methods of another class in addition to new fields and methods. It is defined as parent-child relationship as child also inherits the properties of parent. Here, parent is a main class and child is a sub class which will inherit the properties of main class. [Source: www.codepointing.blogspot.com] In Inheritance, two keywords are mainly used which are extends and super . extends keyword is used to extend sub class to main class while super is used to inherit the properties, methods and constructor of the parent class but child class can not access the private variable of parent class in any way !! Inheritance provides superb code reusability and useful for method overriding to achieve dynamic runtime polymorphism. (which will see in next post soon !) There ar...
Read more

Selenium: Waits

Image
In last post, we have seen how Xpath helps us to find dynamic elements which changes every time. Similarly, most of the front ends are developed with Ajax and JavaScript where different elements load at different time. In such cases, our driver need to wait till the element is loaded and visible otherwise it will throw ' elementNotVisibleException ' exception and eventually our automation script will fail. To avoid such situations we have one powerful option in selenium that is nothing but ' Wait '. [ source: www.deshannonspeaks.com ] In general, we have two types of wait in selenium. Implicit wait Explicit wait 1. Implicit Wait :  This idea is borrowed from Watir. Here, we are instructing our driver to wait for certain amount of time for element to get loaded before throwing an exception. Example : Consider our Facebook login scenario. Implicit wait syntax is highlighted in bold. It will wait for 10 seconds and if any element is not loaded i...
Read more

Selenium: All about XPath Locator in WebDriver

Image
As we have started writing simple web application login like scripts, its time to move one step ahead. Till now we were finding web elements using general locators like id, name, classname etc. but sometimes it is difficult to find elements using these locators. What if elements don't have these locators, What if some elements are dynamically changing, to answer all these questions, we have Xpath . Xpath is used to find complex and dynamically changing web elements of the web page. It is defined as XML path, it is basically a syntax for finding web element using its XML path expression. It takes advantage of HTML DOM structure while finding web elements.  Syntax: Xpath= //tagname[@attribute='value'] // : current node tagname : name of the tags like input, a, img, label etc. attribute : name of the attributes like id, name, classname etc. value : value of that particular attribute There are mainly two types of Xpath. Absolute Xpath:  Xpath finds...
Read more

Selenium: Capturing the screenshot

Image
As an QA engineer, we all know that taking the screenshots is the main task we do during testing particular application. (It works as a 'Brahmastra' while fighting with developers and clients !!). Similarly, while running automation scripts it is necessary to take screenshots of important events and functionalities as it is imperative for bug analysis.  Selenium offers great advantage of taking automatic screenshots during the execution. We can convert our WebDriver instance to TakesScreenshot . Below we will see one example of taking the screenshots in our selenium automation script. [source: www.qaautomated.com ] Example:  Here, simply we will try to open Google, will take the screenshot of that screen and we will store it to our local machine. // importing the needed jar files import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; import com.sun.jna.platform.FileUtils; //creating class ScreenShot @...
Read more

Selenium: Frameworks

Image
In previous posts, we learnt about all the selenium basics for automation script writing. Now, let's move forward with some advance selenium topics such as Framework .  Framework is nothing but set of some predefined protocols and guidelines that how the things will work when we are writing automation scripts. Framework is like 'Single Standard' which is every automation tester is obliged to follow. Basically, framework helps to separate our 'code' and 'data' which will help in achieving higher code readability, reusability and portability. With the help of frameworks, we can test our script with multiple set of data which paves way for very efficient functional testing.   The main advantage of using frameworks is project maintenance as we can easily manage all our automation scripts, test data and all other related stuffs. e.g. different testers work on different modules of the AUT(Application Under Test)  and with the help of frameworks, we can e...
Read more