Selenium Framework — Data-Driven, Keyword Driven & Hybrid
In this article on Selenium Framework, I will tell you how to use a Selenium framework to optimize your code structure and this will move you closer to become a Selenium certified professional.
What is a Selenium Framework?
Selenium framework is a code structure for making code maintenance simpler, and code readability better. A framework involves breaking the entire code into smaller pieces of code, which test a particular functionality.
The code is structured such that, the “data set” is separated from the actual “test case” which will test the functionality of the web application. It can also be structured in a way wherein, the test cases which need to be executed are called (invoked) from an external application (like a .csv).
There are a number of frameworks out there, but 3 commonly used Selenium framework (s) are:
- Data-Driven framework
- Keyword Driven framework
- Hybrid framework
These frameworks will be discussed with a demo in this article. But before going any further, let me tell you why a Selenium framework needs to be in place, and what benefits you will get out of using them.
Why do we need a Selenium framework?
Without a framework in place, there will be one test case which will comprise the entire test functionality. The scary part is, this single test case has the capability to rise up to a million lines of code. So it's pretty obvious that a test case so huge will be tough to read. Even if you want to modify any functionality later, then you will have a tough time modifying the code.
Since the implementation of a framework, will result in smaller but multiple code pieces, there are various benefits.
Benefits of Selenium framework
- Increased code reusage
- Improved code readability
- Higher portability
- Reduced script maintenance
Now that you know the basics of frameworks, let me explain each of them in detail.
Data-Driven Framework
A Data-Driven framework in Selenium is the technique of separating the “data set” from the actual “test case” (code). This framework completely depends on the input test data. The test data is fed from external sources such as an excel file, CSV file or any database.
Since the test case is separated from the data set, we can easily modify the test case of a particular functionality without making wholesale changes to your code. For example, if you want to modify the code for login functionality, then you can modify just that instead of having to also modify any other dependent portion in the same code.
Besides this, you can also easily control how much data needs to be tested. You can easily increase the number of test parameters by adding more username and password fields to the excel file (or other sources).
For example, if I have to check the login to a web page, then I can keep the set of username and password credentials in an excel file and pass the credentials to the code to perform automation on the browser in a separate Java class file.
Using Apache POI With Selenium WebDriver
WebDriver does not directly support reading of excel files. Hence we use Apache POI for reading/ writing to any Microsoft Office document. You can download Apache POI (set of JAR files) from here. Download the zip file or tar file as per your requirement and place them along with the set of Selenium JARs.
The coordination between the main code and data set will be taken care by TestNG Data Providers, which is a library that comes as a part of the Apache POI JAR files. For demo purpose, I have created an excel file called “LoginCredentials” in which the usernames and passwords have been stored in different columns.
Take a look at the below code to understand the test case. It is a simple code for testing the login functionality of a flight booking application.
package DataDriven;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
public class DDTExcel
{
ChromeDriver driver;
@Test(dataProvider="testdata")
public void DemoProject(String username, String password) throws InterruptedException
{
System.setProperty("webdriver.chrome.driver", "C:\\Users\\Vardhan\\Downloads\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://newtours.demoaut.com/");
driver.findElement(By.name("userName")).sendKeys(username);
driver.findElement(By.name("password")).sendKeys(password);
driver.findElement(By.name("login")).click();
Thread.sleep(5000);
Assert.assertTrue(driver.getTitle().matches("Find a Flight: Mercury Tours:"), "Invalid credentials");
System.out.println("Login successful");
}
@AfterMethod
void ProgramTermination()
{
driver.quit();
}
@DataProvider(name="testdata")
public Object[][] TestDataFeed()
{
ReadExcelFile config = new ReadExcelFile("C:\\Users\\Vardhan\\workspace\\Selenium\\LoginCredentials.xlsx");
int rows = config.getRowCount(0);
Object[][] credentials = new Object[rows][2];
for(int i=0;i<rows;i++)
{
credentials[i][0] = config.getData(0, i, 0);
credentials[i][1] = config.getData(0, i, 1);
}
return credentials;
}
}If you noticed from above, we have a method named “TestDataFeed()”. In this method, I have created an object instance of another class named “ReadExcelFile”. While instantiating this object, I have fed the path of my excel file containing the data. I have further defined a loop to retrieve the text from the excel workbook.
But, for reading the data from a given sheet number, column number and row number, the calls are made to the “ReadExcelFile” class. The code of my “ReadExcelFile” is below.
package DataDriven;
import java.io.File;
import java.io.FileInputStream;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
public class ReadExcelFile
{
XSSFWorkbook wb;
XSSFSheet sheet;
public ReadExcelFile(String excelPath)
{
try
{
File src = new File(excelPath);
FileInputStream fis = new FileInputStream(src);
wb = new XSSFWorkbook(fis);
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
public String getData(int sheetnumber, int row, int column)
{
sheet = wb.getSheetAt(sheetnumber);
String data = sheet.getRow(row).getCell(column).getStringCellValue();
return data;
}
public int getRowCount(int sheetIndex)
{
int row = wb.getSheetAt(sheetIndex).getLastRowNum();
row = row + 1;
return row;
}
}First, note the libraries I have imported. I have imported Apache POI XSSF libraries which are used to read/ write data to excel files. Here, I have created a constructor (object of the same method) to pass the values: sheet number, row number and column number.
Now let’s move on to the framework, i.e Keyword Driven framework.
Keyword Driven Framework
Keyword Driven framework is a technique in which all the operations & instructions to be performed are written separately from the actual test case. The similarity it has with Data Driven framework is that, the operations to be performed is again stored in an external file like Excel sheet.
The operations I’m talking about is nothing but the methods that need to be executed as part of a test case. The benefit with Keyword Driven framework is that you can easily control the functionalities you want to test. You can specify the methods which test the functionality of the application in the excel file. Thus, only those method names which are specified in the excel will be tested.
For example, for logging into the web application, we can write multiple methods in the main test case, in which each test case will test certain functionality. For instantiating the browser driver there could be one method, for finding the username & password fields, there could be methods, for navigating to a web page there could be another method, etc.
Take a look at the below code for understanding how the framework looks. The lines which are commented out in the below code serve as an explanation if you don’t understand.
package KeywordDriven;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
public class Actions
{
public static WebDriver driver;
public static void openBrowser()
{
System.setProperty("webdriver.chrome.driver", "C:\\Users\\Vardhan\\Downloads\\chromedriver.exe");
driver=new ChromeDriver();
}
public static void navigate()
{
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
driver.get("http://newtours.demoaut.com");
}
public static void input_Username()
{
driver.findElement(By.name("userName")).sendKeys("mercury");
}
public static void input_Password()
{
driver.findElement(By.name("password")).sendKeys("mercury");
}
public static void click_Login()
{
driver.findElement(By.name("login")).click();
}
@Test
public static void verify_login()
{
String pageTitle = driver.getTitle();
Assert.assertEquals(pageTitle, "Find a Flight: Mercury Tours:");
}
public static void closeBrowser()
{
driver.quit();
}
}As you can see, the different functionalities which need to be tested are present in separate methods waiting to be called. Now, these methods will be called from another Class, based on the presence of the method name in the excel file. And similarly, to read the excel file, and send back the results, I have written another Class. Both of them are displayed below.
The class file invoking the methods is this.
package KeywordDriven;
public class DriverScript
{
public static void main(String[] args) throws Exception
{
//Declaring the path of the Excel file with the name of the Excel file
String sPath = "C:\\Users\\Vardhan\\workspace\\Selenium Frameworks Demo\\dataEngine.xlsx";
//Here we are passing the Excel path and SheetName as arguments to connect with Excel file
ReadExcelData.setExcelFile(sPath, "Sheet1");
//Hard coded values are used for Excel row & columns for now
//Hard coded values are used for Excel row & columns for now
//In later chapters we will replace these hard coded values with varibales //This is the loop for reading the values of the column 3 (Action Keyword) row by row
for (int iRow=1;iRow<=7;iRow++)
{
String sActions = ReadExcelData.getCellData(iRow, 1);
//Comparing the value of Excel cell with all the keywords in the "Actions" class
if(sActions.equals("openBrowser"))
{
//This will execute if the excel cell value is 'openBrowser'
//Action Keyword is called here to perform action
Actions.openBrowser();
}
else if(sActions.equals("navigate"))
{
Actions.navigate();
}
else if(sActions.equals("input_Username"))
{
Actions.input_Username();
}
else if(sActions.equals("input_Password"))
{
Actions.input_Password();
}
else if(sActions.equals("click_Login"))
{
Actions.click_Login();
}
else if(sActions.equals("verify_Login"))
{
Actions.verify_login();
}
else if(sActions.equals("closeBrowser"))
{
Actions.closeBrowser();
}
}
}
}And the class file which reads the Excel values is this.
package KeywordDriven;
import java.io.FileInputStream;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
public class ReadExcelData
{
private static XSSFSheet ExcelWSheet;
private static XSSFWorkbook ExcelWBook;
private static XSSFCell Cell;
//This method is to set the File path and to open the Excel file
//Pass Excel Path and SheetName as Arguments to this method
public static void setExcelFile(String Path,String SheetName) throws Exception
{
FileInputStream ExcelFile = new FileInputStream(Path);
ExcelWBook = new XSSFWorkbook(ExcelFile);
ExcelWSheet = ExcelWBook.getSheet(SheetName);
}
//This method is to read the test data from the Excel cell
//In this we are passing parameters/arguments as Row Num and Col Num
public static String getCellData(int RowNum, int ColNum) throws Exception
{
Cell = ExcelWSheet.getRow(RowNum).getCell(ColNum);
String CellData = Cell.getStringCellValue();
return CellData;
}
}Now, let’s move onto the final part of this article, where I will show you how to build a Hybrid framework.
Hybrid framework
Hybrid framework is a technique wherein we can make the best use of both Data Driven & Keyword Driven Selenium framework (s). Using the examples shown above in this article, we can build a Hybrid framework by storing the methods to execute in an excel file (keyword driven approach) and passing these method names to the Java Reflection Class (data-driven approach) instead of creating an If/Else loop in the “DriverScript” class.
Take a look at the modified “DriverScript” class in the below code snippet. Here, instead of using multiple If/ Else loops, data-driven approach is used to read the method names from the excel file.
package HybridFramework;
import java.lang.reflect.Method;
public class DriverScriptJava
{
//This is a class object, declared as 'public static'
//So that it can be used outside the scope of main[] method
public static Actions actionKeywords;
public static String sActions;
//This is reflection class object, declared as 'public static'
//So that it can be used outside the scope of main[] method
public static Method method[];
public static void main(String[] args) throws Exception
{
//Declaring the path of the Excel file with the name of the Excel file
String sPath = "C:\\Users\\Vardhan\\workspace\\Selenium Frameworks Demo\\dataEngine.xlsx";
//Here we are passing the Excel path and SheetName to connect with the Excel file
//This method was created previously
ReadExcelData.setExcelFile(sPath, "Sheet1");
//Hard coded values are used for Excel row & columns for now
//Later on, we will use these hard coded value much more efficiently
//This is the loop for reading the values of the column (Action Keyword) row by row
//It means this loop will execute all the steps mentioned for the test case in Test Steps sheet
for (int iRow=1;iRow<=7;iRow++)
{
sActions = ReadExcelData.getCellData(iRow, 1);
//A new separate method is created with the name 'execute_Actions'
//You will find this method below of the this test
//So this statement is doing nothing but calling that piece of code to execute
execute_Actions();
}
}
//This method contains the code to perform some action
//As it is completely different set of logic, which revolves around the action only, it makes sense to keep it separate from the main driver script
//This is to execute test step (Action)
private static void execute_Actions() throws Exception
{
//Here we are instantiating a new object of class 'Actions'
actionKeywords = new Actions();
//This will load all the methods of the class 'Actions' in it.
//It will be like array of method, use the break point here and do the watch
method = actionKeywords.getClass().getMethods();
//This is a loop which will run for the number of actions in the Action Keyword class
//method variable contain all the method and method.length returns the total number of methods
for(int i = 0;i<method.length;i++)
{
//This is now comparing the method name with the ActionKeyword value received from the excel
if(method[i].getName().equals(sActions))
{ //In case of match found, it will execute the matched method
method[i].invoke(actionKeywords);
//Once any method is executed, this break statement will take the flow outside of for loop
break;
}
}
}
}I hope this article was useful to you and gave you a clear understanding of what a Selenium framework is, how it is beneficial and how to build your code structure using these 3 Selenium frameworks.
If you wish to check out more articles on the market’s most trending technologies like Artificial Intelligence, DevOps, Ethical Hacking, then you can refer to Edureka’s official site.
Do look out for other articles in this series which will explain the various other aspects of Selenium.
2. Selenium WebDriver: TestNG For Test Case Management & Report Generation
6. Setting up a Selenium Grid for distributed Selenium testing
8. Cross Browser Testing Using LambdaTest
9. Cross Browser Testing Using Selenium
10. Handle Multiple Windows in Selenium
11. Page Object Model In Selenium
13. QTP vs Selenium
14. Selenium vs RPA
15. Selenium WebDriver Architecture
Originally published at www.edureka.co on April 5, 2018.
