by admin | Aug 2, 2021 | Analytics Testing, Blog, Latest Post |
Currently, we are extracting the data from different source systems, transforming it, and then finally loading it into the data warehouses. But when it comes to DBT, the raw source data from different source systems are extracted and directly loaded into the warehouse. After which, DBT allows us to create new materialized tables into which the transformed data is fed as it helps showcase the meaningful data for business analysis purposes by using simple select statements. But what makes DBT stand tall is it allows both the development and production environment teams to work in the same place by creating models & testing the scripts for transformation purposes. Being one of the leading QA companies, we will be mainly focusing on the testing part of the above process in this DBT Tutorial by exploring how we test our models.
What is DBT?
If you’re new to the DBT tool, worry not, we have got some basics in this DBT Tutorial for you as well. The Data Build Tool (DBT) is an open-source test automation tool and a command-line tool. It mainly focuses on the transformation part in the “Extract load and transform” pipeline. DBT allows both data analysts and data engineers to build the models and transform the data in their warehouses to make it meaningful.
New to DBT tool?
Let’s walk you through some of the basics to help you get a quick overview of DBT and the necessary steps that have to be done to create an account. Basically, there are two ways for DBT to be used:
1. DBT CLI(Command Line Interface):
The DBT CLI variant allows users to write their scripts and test them locally by using the DBT command-line tool.
2. DBT Cloud:
The DBT Cloud is a facilitated variant that smooths out an advancement with an online Integrated Development Environment, an interface to write our DBT test scripts and run them on a schedule.
In this DBT Tutorial, we will be covering the DBT cloud variant. It is worth noting that the ideas and practices can be stretched out to the CLI variant as well. So let’s get started.
Data warehouse:
As stated earlier, the DBT is used to handle the transformation part of the ELT for data warehousing. “But how does it work?” you might ask. Well, DBT helps us create a connection with the warehouse and then lets us write the SQL simple select statements against the warehouse to transform the data.
Supported Warehouses:
We have listed the names of the supported warehouses in DBT, and they are
• Postgres
• Redshift
• BigQuery
• Snowflake
• Apache Spark
• Databricks and
• Presto (Partially Supported).
We would be using the Snowflake warehouse in this blog for demonstration purposes.
DBT Tutorial for the Setup:
Now that we have seen an overview of DBT, let’s find out how to set up the DBT cloud and use its interface. If you’ve not yet created an account in DBT, you can sign up for DBT cloud by visiting their Sign up page.
Once you are done with your DBT cloud sign-up process, let’s find out how to set up your very first DBT project.
DBT recommends using GitHub to store our deployments. So the first step would be to create an empty repository in GitHub as shown below.
Enter your repository name and click on ‘Create repository’.
Once you have signed up with your DBT cloud, just select the snowflake warehouse and start configuring it using your snowflake credentials. We have shown a sample connection in the below images for your reference.
After entering your warehouse and database details, make sure you have entered the snowflake user name and password in development credentials. Next, click on ‘Continue’ to get this confirmation message “Connection Test Success”. Now, you have to click on the ‘Continue’ button for configuring the GitHub. Since you’re done with GitHub configuration, we’re good to start with DBT.
DBT Tutorial for its Interface:
DBT has a lot of inbuilt options that help access and understand it easily. After setting up with DBT, the interface of DBT that we get to see initially will look like how it is shown in the image below.
As you can see, DBT might initially look a bit empty and even show that the compilation error at the bottom right. So we would have to click on ‘Initialize your Project’ to start our first project. Doing this will make the DBT will provide us with a skeleton as shown in the below image for our project automatically.
We can clearly see that the compilation message that was displayed at the right bottom has now changed to become ‘ready’, implying that it is time to start our project. So let’s get started.
First off, let’s find out the scope of some of the functions,
1. The commit button will handle all our git configurations like creating a new branch, pull request, commit, merge, etc.
2. After writing any SQL statements we can check the query then and there by using the dbt “preview data” and “compile SQL” buttons.
3. We can run and test our models by writing simple DBT commands (e.g. dbt debug, dbt run, dbt test).
4. DBT also generates documentation that will come in very handy for analytical purposes as it will contain all the details about the project. You can access it by clicking on the “view docs” option as shown in the above pic.
Note: Before running any model or a test, make sure that you have saved it.
Loading training data into the Warehouse:
So as stated earlier, DBT cloud currently supports only BigQuery, Postgres, Redshift & Snowflake warehouses, and we have decided to use Snowflake for the demo. So to illustrate how to import or load your training data into the warehouse, we will be loading the two tables that we have created.
Snowflake:
It is important to note that we have written the below instructions assuming that you have the database named compute_wh in your Snowflake account. So make sure that you have the required privileges to create the objects in this database.
Run the following commands in your Snowflake Warehouse SQL Runner:
To create the Database:
Create database STUDENT;
Create Schema STUDENT_INFO:
Use schema STUDENT_INFO;
To create the Tables:
Table 1: Student_Profile
Table 1 will contain the personal information of the students.
Create table student_profile (
S_no int not null,
Std_id int not null,
Std_name varchar(45) null,
Std_dep varchar(45) null,
DOB datetime null,
Primary key (Std_id));
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('1', '294', 'Afshad', 'CSE', '03/10/1998');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('2', '232', 'Sreekanth', 'Mech', '02/09/1997');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('3', '276', 'John', 'EEE', '10/06/1998');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('4', '303', 'Rahul', 'ECE', '12/05/1997');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('5', '309', 'Sam', 'Civil', '09/04/1999');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('6', '345', 'Ram', 'CA', '03/11/1998');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('7', '625', 'Priya', 'CSE', '03/12/1996');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('8', '739', 'Bob', 'MEC', '06/07/1998');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('9', '344', 'Ganesh', 'Mech', '07/09/2024');
insert into student_profile (S_no, Std_id, Std_name, Std_dep, DOB) values ('10', '123', 'Neha', 'ECE', '12/09/1998');
Table 2: STUDENT_RESULTS
Table 2 will contain the results of those students.
Create table student_results (
S_no int not null,
Std_id int not null,
Marks int null,
Result varchar(45) null,
Primary key (Std_id));
insert into student_results (S_no, Std_id, Marks, Result) values ('1', '294', '78', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('2', '232', '56', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('3', '276', '88', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('4', '303', '67', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('5', '309', '38', 'Fail');
insert into student_results (S_no, Std_id, Marks, Result) values ('6', '345', '90', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('7', '625', '87', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('8', '739', '45', 'Fail');
insert into student_results (S_no, Std_id, Marks, Result) values ('9', '344', '97', 'Pass');
insert into student_results (S_no, Std_id, Marks, Result) values ('10', '123', '49', 'Fail');
Now that you have the training data in your warehouse, you are one step away from starting your DBT testing.
DBT Tutorial for the available Models:
In analytics, the process of modeling is changing the data from being the raw data to the final transformed data. Typically the data engineers are responsible for building tables that represents your source data, and on top of that, they also build the tables/views that transform the data step by step.
The models are just SQL select statements in your dbt project. These models are created inside the Models directory with the .sql extension.
What’s great about dbt is you don’t need to know DDL/DML to build the tables or views.
Note: The name of the file is used as the model or table name in your warehouse.
Creating Models:
Inside the model’s directory, we have created two simple models for better understanding.
Model 1:Student_profile.sql
{{ config(materialized='table') }}
with source_data as (
select
S_No,
Std_Id,
Std_Name,
Std_Dep,
DOB
from
STUDENT.STUDENT_INFO.STUDENT_PROFILE
)
select *
from source_data
Model 2: Student_Results.sql
{{ config(materialized='table') }}
with source_data as (
select
S_No,
Std_Id,
Marks,
Result
from
STUDENT.STUDENT_INFO.STUDENT_RESULTS
)
select *
from source_data
Once you’ve built your models, make sure to save and run the models to load them into the warehouse. You can use the ‘dbt run’ command to run your created models, or if you want to run any particular model, you can use the ‘dbt run –Student_Profile’ command.
DBT will show detailed information about the models when you run your models as shown in the above image. So we have successfully completed all the required steps and can move forward to find out how to perform testing in DBT.
DBT Tutorial to perform Testing:
We all know that testing plays a major role in deployment, so tests in analytics are just assertions that you have about your data. But what makes these assertions important is that if these assertions are met, it’ll be instrumental in helping others trust you by looking at the data.
The great part of DBT testing is that by default it provides four data quality checks. They are Unique, Not Null, Relationships (Referential Integrity), and Accepted Value checks.
Basically, DBT provides us with two types of testing. So let’s take a look at the steps to be done to perform the first type, the Schema test.
1. Schema Test:
Create a YAML file in the same model’s directory with a .yml Extension (Ex. Schema.yml).
Configure your tests (Unique, Not Null, Relationships, and Accepted Values) in the YAML file based on your table data and run it by using the command “dbt test”.
Note: Yaml is a data serialization and human-readable language that can be easily understood even by non-technical people. It is mainly used for configuration purposes as it supports all programming languages.
We have attached one YAML file for your reference below.
Schema.yml:
version: 2
models:
- name: student_profile
description: "Table contains all the information about the students"
columns:
- name: std_id
description: "The primary key for this table"
tests:
- unique
- not_null
- name: student_results
description: "Table contains the student results info"
columns:
- name: std_id
description: "The primary key for this table"
tests:
- unique
- not_null
- relationships:
to: ref('student_profile')
field: std_id
- name: result
description: "Result of a student"
tests:
- accepted_values:
values:
- pass
- fail
Once you run this test, you will get detailed information on all your tests. If you need to run only one particular schema test, you can use this command “dbt test –m Student_results”.
2. Data Test:
But if you are looking to write custom test scripts based on the requirements against the data, that also can be done by using tests of this type.
Start by creating the SQL files with your test name inside the test directory of the DBT project as shown below.
Now, add your test script to your test file.
Duplicate.sql:
select std_id, count(std_id)
from {{ref('student_profile')}}
group by std_id
having count(std_id)>2
referential_integrity.sql:
select std_id
from {{ref('student_profile')}}
where std_id not in (
select std_id
from {{ref('student_results')}} )
Note:
Here ref function is used to refer one or more specific files into the script.
Finally, you can run the test by using the “dbt test –data” command.
DBT Tutorial for Documentation:
As discussed earlier, documentation is one of the greatest features of DBT. So once your project is completed, all you have to do is use the “dbt docs –generate” command to generate the document.
After running the command, just click on “view docs” at the top left of the DBT interface to view the complete information about your project in the form of a document. It even generates a lineage graph like the one shown below for a crystal clear understanding.
DBT also supports filters in the lineage graph, which is a great advantage when it comes to analysis.
Conclusion:
We hope that you have enjoyed reading this DBT Tutorial blog and also hope that DBT would be a great addition to your toolkit. To sum things up, DBT helps carry out the most complex and heavy transformations in a simple and easy manner by using simple select statements. It enables both data engineers and data analysts to work in the same environment and provides a unique experience for them to transform the data. The models in DBT enable faster execution and also make it so easy to test and modify. Finally, it even shows detailed information about the project by generating the document along with a lineage graph for clear analysis purposes. All thanks to such awesome features, DBT has been a resourceful tool that has helped us deliver the best software testing services to our clients.
Frequently Asked Questions
-
What is dbt tool used for?
DBT (Data Build Tool) is used to perform the Transform part of the ETL (Extract Transform Load) process in a simplified manner by writing transformations as queries and orchestrating them effectively.
-
What is DBT testing?
DBT testing is the process of ensuring the data you have is reliable by using assertions you have about the data as tests. There are 2 types of dbt testing; namely Schema Test and Data Test.
-
What are the four generic tests that dbt ships with?
The 4 generic tests that dbt ships with are Unique, Not Null, Relationships (Referential Integrity), and Accepted Value checks.
-
What does dbt stand for data?
DBT stands for Data Build Tool and as the name suggests, dbt can be used to transform data in warehouses in an effective manner.
-
Can I use dbt for free?
Yes, you can use dbt Core for free as it is an open-source tool released under an Apache 2.0 License. But dbt Cloud is not a completely free tool as few features are restricted in the free version.
by admin | Jul 29, 2021 | QA Outsourcing, Blog, Latest Post |
QA outsourcing has a major role to play in the success of an application or software as an app might have 100 awesome features, but if there is just one small bug that troubles the customer, then that is what will define the experience of the user. The one bug will outweigh all the positives and stick out like a sore thumb in the customer’s memory. Once a mindset like that has been created, there is simply no going back. The impact of that bug will forever be a deep dent that spoils the outlook of the product. So an app that is not properly tested will result in its creators paying a big price in terms of finance and reputation.
The solution here would be to employ a high-caliber testing team to take care of the scripted testing, regression testing, and real-world testing so that the in-house team can concentrate on new features instead of focusing on iterative testing. That’s where QA outsourcing comes into play, as one can get a highly skilled and capable team to test their software and also cut costs in their budget.
A Statistical viewpoint of Outsourcing
It’s not just us who are claiming this to be a successful strategy, the statistics behind our statement is also as strong as it can get. In 2019, the global IT outsourcing market had reached a mammoth value of $333.7 Billion. But the most interesting fact is that it is on a CAGR of 4.5% and is expected to reach $397.6 Billion by 2025. According to a recent survey, 83% of IT leaders are having plans to outsource their security to an MSP in 2021. So is it just the big fish at work here? No, 37% of small businesses have also opted for outsourcing as they have witnessed increased efficiency.
What makes Outsourcing the way to go?
So why are so many companies outsourcing? Is it only because of the cost? Cost is an important reason, but not the only reason. Every project has a budget cap and the management will always be on the lookout for the most efficient path to success. So outsourcing becomes the obvious solution here as though outsourcing is cost-efficient, it is in no way different in quality. When it comes to QA outsourcing, factors such as the average income of a QA Engineer and the hourly rate are what cause this difference.
So it is evident here that the cost of the work varies from one region to region. But it is also worth noting that the cost is the only factor that is changing across regions and not the quality of work. In fact, we could even go beyond and say that QA outsourcing increases the level of quality. Now, coming back to the main question. Is cost the only major factor? No, the value that the QA outsourcing companies like us provide is off the charts in comparison. Even if we assume that a team has an unlimited supply of resources at their disposal, QA outsourcing would still be the better option as QA outsourcing software testing nullifies the impact of cognitive bias in the process.
As a top QA company ourselves, we are hard on our testing to make it easier for our clients to smoothly launch their new products with the utmost confidence.
An Adaptable choice
Let’s take a deeper dive into the value that we speak so highly of. We have already brushed through the fact that all businesses irrespective of their scale find QA outsourcing to be resourceful. So if it’s a small startup wondering how to make room for software testing in their budget, QA outsourcing has the ability to ensure software quality while still being on a budget. If it is a bigger company, they will be able to get a far more experienced team in the same price bracket through QA outsourcing.
There might even be a short-term need that requires just a week or two of software testing. Building an in-house team or recruiting an employee for such a short period of time will be a cumbersome task that may not yield the best results as well. Every project is unique to itself and would demand a special set of skills from the testing team. As an experienced software testing service provider, we are experts in handling any challenge that comes our way all thanks to our dedicated teams for all types of testing such as manual, automation, performance, and the list could just keep going. On the whole, QA outsourcing can solve all such problems and most importantly save everyone from the unnecessary hassle.
A Proof of Concept
Despite all the goods we have seen, there are cases where people could be on the fence and still be skeptical about going forward with QA outsourcing. The next move that could potentially make all the doubts fly away would be to approach a QA company and get a Proof of Concept. A POC helps the person witness the QA team’s expertise with the solutions they bring to the table. Most importantly, a POC will instill more confidence as it helps to analyze the QA team beyond just their successful track record.
That is why we trust in our ability and provide a free POC to not just establish the fact that we have what it takes to ensure software quality, but also lay a foundation for the successful partnership that is in the making. You’re just a step away from getting the best software testing services, so take a step in the right direction and contact us now.
by Anika Chakraborty | Jul 26, 2021 | Automation Testing, Blog, Latest Post |
Reducing the complexity of any process is always the key to better performance, similarly parsing the XML data to obtain a readable format of that XML file that we humans can understand is also a very important process. A simple equivalent to this parsing process would be the process of language translation. Let’s take the example of two national leaders discussing an important meeting. They could either choose to use a common language like English or talk in the languages they are comfortable with and use translators to solve the purpose. Likewise, the XML will be in a format that is easily understood by a computer, but once the information has been parsed, we will be able to read data from XML and understand it with ease.
As one of the leading QA companies in the market, we use different parsers based on our needs and so let’s explore which parser would be the perfect match for your need by understanding how they work. But before we explore how we can read data from XML, let us get introduced to XML first as there might be a few readers who may not know much about XML.
An Introduction to the XML:
XML stands for Extensible mark-up Language, and it’s primarily used to describe and organize information in ways that are easily understandable by both humans and computers. It is a subset of the Standard Generalized Mark-up Language (SGML) that is used to create structured documents. In XML, all blocks are considered as an “Element”. The tags are not pre-defined, and they are called “Self-descriptive” tags as it enables us to create our own customized tags. It also supports node-to-node interaction to fill the readability gap between Humans and Machines.
XML is designed to store and transfer data between different operating systems without us having to face any data loss. XML is not dependant on any platform or language. One can say that XML is similar to HTML as it neither acts as the frontend nor as the backend. For example, we would have used HTML to create the backend code, and that code would be passed to the frontend where it is rendered as a webpage.
Prerequisite:
There are a few basic prerequisites that should be ready in order to read data from XML, and we have listed them below,
1. Install any IDE(Eclipse/Intellij )
2. Make sure if Java is installed
3. Create a Java project in IDE
4. Create an XML file by using .xml extension
XML file creation:
So the first three steps are pretty straightforward, and you may not need any help to get it done. So let’s directly jump to the fourth and final prerequisite step, where we have to create an XML file manually in our Java project.
Navigate to the File tab in your IDE
– Create a new file
– Save it as “filename.xml”
The XML file will display under your Java project. In the same way, we can create the XML file in our local machine by using the .xml file extension. Later, we can use this XML file path in our program for parsing the XML. Let’s see the technologies for parsing the XML.
XML Parse:
XML parsing is nothing but the process of converting the XML data into a human-readable format. The XML parsing can be done by making use of different XML Parsers. But what do these parsers do? Well, parsers make use of the XSL Transformation (XSLT) processor to transform the XML data to a readable format and paves the way for using XML in our programs. The most commonly used parsers are DOM, SAX, StAX, Xpath, and JDOM. So let’s take a look at each parses one-by-one..
Using DOM Parser to Read data from XML:
DOM stands for Document Object Model. DOM is a parser that is both easy to learn and use. It acts as an interface to access and modify the node in XML. DOM works by building the entire XML file into memory and moving it node by node in a sequential order to parse the XML. DOM can be used to identify both the content and structure of the document. But the setback that comes with DOM is that it is slow and consumes a large amount of memory because of the way it works. So DOM will be an optimal choice if you are looking to parse a smaller file and not a very large XML file as everything in DOM is a node in the XML file. Let’s see how to parse the below XML by using the DOM parser.
Here is the XML File that we need to parse:
<?xml version = "1.0"?>
<Mail>
<email Subject="Codoid Client Meeting Remainder">
<from>Priya</from>
<empid>COD11</empid>
<Designation>Software Tester</Designation>
<to>Karthick</to>
<body>We have meeting at tomorrow 8 AM. Please be available
</body>
</email>
<email Subject="Reg:Codoid Client Meeting Remainder ">
<from>Kartick</from>
<empid>COD123</empid>
<Designation>Juniour Software Tester</Designation>
<to>Priya</to>
<body>Thanks for reminding me about the meeting. Will join on time</body>
</email>
</Mail>
DOM Parser:
package com.company;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.IOException;
public class DOMParser {
public static void main(String[] args) throws ParserConfigurationException, IOException, SAXException {
try {
File file = new File("E:\\Examp\\src\\com\\company\\xmldata.xml");
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
Document doc = builder.parse(file);
doc.getDocumentElement().normalize();
System.out.println("Root element:: " + doc.getDocumentElement().getNodeName());
NodeList nList = doc.getElementsByTagName("email");
for (int temp = 0; temp < nList.getLength(); temp++) {
Node nNode = nList.item(temp);
System.out.println("\nCurrent Element :" + nNode.getNodeName());
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
System.out.println("Email Subject : "
+ eElement.getAttribute("Subject"));
System.out.println("From Name : "
+ eElement
.getElementsByTagName("from")
.item(0)
.getTextContent());
System.out.println("Designation : "
+ eElement
.getElementsByTagName("Designation")
.item(0)
.getTextContent());
System.out.println("Employee Id : "
+ eElement
.getElementsByTagName("empid")
.item(0)
.getTextContent());
System.out.println("To Name : "
+ eElement
.getElementsByTagName("to")
.item(0)
.getTextContent());
System.out.println("Email Body : "
+ eElement
.getElementsByTagName("body")
.item(0)
.getTextContent());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
We have created a DocumentBuilderFactory API to produce the object trees from XML, after which we’ve also created a document interface to access the XML document data. As stated earlier, the node is the base datatype for DOM here. From the code, we can see that the getDocumentElement() method will return the root of the element, and the getElementsByTagName() method will return the value of that particular tag.
Using the SAX Parser to Read data from XML:
The SAX parser is a simple event-based API that parses the XML document line-by-line using the Handler class. Everything in XML is considered to be “Tokens” in SAX. Unlike the DOM parser that we saw earlier, SAX does not load the entire XML file into memory. It also doesn’t create any object representation of the XML document. Instead, it triggers events when it encounters the opening tag, closing tag, and character data in an XML file. It reads the XML from top to bottom and identifies the tokens and call-back methods in the handler that are invoked. Due to the top to bottom approach, tokens are parsed in the same order as they appear in the document. Due to the change in the way SAX works, it is faster and uses less memory in comparison to the DOM parser.
SAX Parser:
try{
File file = new File("E:\\Examp\\src\\com\\company\\xmldata.xml");
SAXParserFactory saxParserFactory= SAXParserFactory.newInstance();
SAXParser saxParser= saxParserFactory.newSAXParser();
SaxHandler sax= new SaxHandler();
saxParser.parse(file,sax);
}
catch (Exception e){
e.printStackTrace();
}
}
}
In the above code, we have created an XML file and given its path in the code. The SAXParserFactory used in the code creates the new instance for that file. After that, we can create the object for the Handler class using which we parse the XML data. So we have called the handler class method by using the object. Now, let’s see how the Handler class and its method are created.
class SaxHandler extends DefaultHandler{
boolean from=false;
boolean to=false;
boolean Designation= false;
boolean empid= false;
boolean body=false;
StringBuilder data=null;
@Override
public void startElement(String uri, String localName,
String qName, Attributes attributes){
if(qName.equalsIgnoreCase("email")){
String Subject= attributes.getValue("Subject");
System.out.println("Subject:: "+Subject);
}
else if(qName.equalsIgnoreCase("from")){
from=true;
}
else if(qName.equalsIgnoreCase("Designation")){
Designation=true;
}
else if(qName.equalsIgnoreCase("empid")){
empid=true;
}
else if(qName.equalsIgnoreCase("to")){
to=true;
}
else if(qName.equalsIgnoreCase("body")) {
body = true;
}
data=new StringBuilder();
}
@Override
public void endElement(String uri, String localName, String qName){
if(qName.equalsIgnoreCase("email")){
System.out.println("End Element:: "+qName);
}
}
@Override
public void characters(char ch[], int start, int length){
// data.append(new String(ch,start,length));
if(from){
System.out.println("FromName:: "+new String(ch,start,length));
from=false;
}
else if(Designation){
System.out.println("Designation:: "+new String(ch,start,length));
Designation=false;
}
else if(empid){
System.out.println("empid:: "+new String(ch,start,length));
empid=false;
}
else if(to){
System.out.println("to:: "+new String(ch,start,length));
to=false;
}
else if(body){
System.out.println("body:: "+new String(ch,start,length));
body=false;
}
}
}
Our ultimate goal is to read data from XML using the SAX parser. So in the above example, we have created our own SAX Parser class and also extended the DefaultHandler class which has various parsing methods. The 3 most prevalent methods of the DefaultHandler class are:
1. startElement() – It receives the notification of the start of an element. It has 3 parameters which we have explained by providing the data that has to be used.
startElement(String uri, String localName,String qName, Attributes attributes)
uri – The Namespace URI, or the empty string if the element has no Namespace URI.
localName – The local name (without prefix) or the empty string if Namespace processing is not being performed.
qName – The qualified name (with prefix) or the empty string if qualified names are not available.
attributes – The attributes attached to the element. If there are no attributes, it shall be an empty attributes object.
The startElement() is used to identify the first element of the XML as it creates an object every time a start element is found in the XML file.
2. endElement() – So we have already seen about startElement(), and just as the name suggests, endElement() receives the notification of the end of an element.
endElement (String uri, String localName, String qName)
uri – The Namespace URI, or the empty string if the element has no Namespace URI
localName – The local name (without prefix) or the empty string if Namespace processing is not being performed.
qName – The qualified name (with prefix) or the empty string if qualified names are not available.
The endElement() is used to check the end element of the XML file.
3.characters() – Receives the notification of character data inside an element.
characters (char ch[], int start, int length)
ch – The characters.
start – The start position in the character array.
length – The number of characters that have to be used from the character array.
characters() is used to identify the character data inside an element. It divides the data into multiple character chunks. Whenever a character is found in an XML document, the char() will be executed. That’s why we append() the string to keep this data.
Using the JDOM Parser to Read data from XML:
So the JDOM parser is a combination of the DOM and SAX parsers that we have already seen. It’s an open-source Java-based library API. The JDOM parser can be as fast as the SAX, and it also doesn’t require much memory to parse the XML file. In JDOM, we even can switch the two parsers easily like DOM to SAX, or vice versa. So the main advantage is that it returns the tree structure of all elements in XML without impacting the memory of the application.
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class JDOMParser {
public static void main(String[] args) throws JDOMException, IOException {
try{
File file = new File("E:\\Examp\\src\\com\\company\\xmldata.xml");
SAXBuilder saxBuilder = new SAXBuilder();
Document doc= saxBuilder.build(file);
System.out.println("Root element :" + doc.getRootElement().getName());
Element ele= doc.getRootElement();
List<Element> elementList = ele.getChildren("email");
for(Element emailelement: elementList){
System.out.println("Current element:: "+emailelement.getName());
Attribute attribute= emailelement.getAttribute("Subject");
System.out.println("Subject:: "+attribute.getValue());
System.out.println("From:: "+emailelement.getChild("from").getText());
System.out.println("Designation:: "+emailelement.getChild("Designation").getText());
System.out.println("Empid:: "+emailelement.getChild("empid").getText());
System.out.println("To:: "+emailelement.getChild("to").getText());
System.out.println("Body:: "+emailelement.getChild("body").getText());
}
}
catch (Exception e){
e.printStackTrace();
}
}
}
We have used the SAXBuilder class to transform the XML to a JDOM document. The getRootElement() is used to find the starting element of the XML and store all the elements from the XML to a list based on the starting element and iterate that element list. At the very end, we have used the getText() method to get the value of each attribute.
Using the StAX Parser to Read data from XML:
The StAX Parser is similar to the SAX Parser with just one difference. That major difference is that it employs 2 APIs (Cursor based API and Iterator-based API) to parse the XML. The StAX parser is also known as the PULL API, and it gets the name from the fact that we can use it to access the information from the XML whenever needed. The other standout aspect of the StAX parser is that it can read and also write the XML. Every element in the XML is considered as “Events”, and below is the code that we require for parsing the XML file using the StAX Parser.
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader eventReader =
factory.createXMLEventReader(new FileReader("E:\\Examp\\src\\com\\company\\xmldata.xml "));
while(eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
switch(event.getEventType()) {
case XMLStreamConstants.START_ELEMENT:
StartElement startElement = event.asStartElement();
String qName = startElement.getName().getLocalPart();
if (qName.equalsIgnoreCase("email")) {
System.out.println("Start Element : email");
Iterator<Attribute> attributes = startElement.getAttributes();
String rollNo = attributes.next().getValue();
System.out.println("Subject " + Subject);
} else if (qName.equalsIgnoreCase("from")) {
EmailFrom = true;
} else if (qName.equalsIgnoreCase("empid")) {
Empid = true;
} else if (qName.equalsIgnoreCase("Designation")) {
Desination = true;
}
else if (qName.equalsIgnoreCase("to")) {
EmailTo = true;
}
else if (qName.equalsIgnoreCase("body")) {
EmailBody = true;
}
break;
case XMLStreamConstants.CHARACTERS:
Characters characters = event.asCharacters();
if(EmailFrom) {
System.out.println("From: " + characters.getData());
EmailFrom = false;
}
if(Empid) {
System.out.println("EmpId: " + characters.getData());
Empid = false;
}
if(Desination) {
System.out.println("Designation: " + characters.getData());
Desination = false;
}
if(EmailTo) {
System.out.println("to: " + characters.getData());
EmailTo = false;
}
if(EmailBody) {
System.out.println("EmailBody: " + characters.getData());
EmailBody = false;
}
break;
case XMLStreamConstants.END_ELEMENT:
EndElement endElement = event.asEndElement();
if(endElement.getName().getLocalPart().equalsIgnoreCase("email")) {
System.out.println("End Element : email");
System.out.println();
}
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}}
In StAX, we have used the XMLEventReader interface that provides the peek at the next event and also returns the configuration information.
The StartElement interface give access to the start elements in XML and the asStartElement() method returns the startElement event. It is important to note that the exception will be shown if the start element event doesn’t occur.
All character events are reported using the Characters interface. If you are wondering what would get reported as character events? The answer is that all the text and whitespaces events are reported as characters events.
The asCharacters() method returns the Characters from XML, and we will be able to get the data from XML as characters using the getData() method. Though it iterates each and every data from the XML and gives it in the form of a tree structure, it doesn’t return the start and end element events.
The EndElement class is used to point and return the end of the elements in an XML doc.
Using the Xpath Parser to Read data from XML:
The Xpath parser is a query language that is used to find the node from an XML file and parse the XML based on the query string. Now let’s take a look at an example code for better understanding.
File inputFile = new File("E:\\Examp\\src\\com\\company\\xmldata.xml");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
// DocumentBuilder dBuilder;
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(inputFile);
doc.getDocumentElement().normalize();
XPath xPath = XPathFactory.newInstance().newXPath();
String expression = "/Mail/Email";
NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(doc, XPathConstants.NODESET);
for (int i = 0; i < nodeList.getLength(); i++) {
Node nNode = nodeList.item(i);
System.out.println("\nCurrent Element :" + nNode.getNodeName());
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
System.out.println("From : " + eElement.getElementsByTagName("from").item(0).getTextContent());
System.out.println("EmpId : " + eElement.getElementsByTagName("empid").item(0).getTextContent());
System.out.println("Designation : " + eElement.getElementsByTagName("Designation").item(0).getTextContent());
System.out.println("TO : " + eElement.getElementsByTagName("to").item(0).getTextContent());
System.out.println("Body : " + eElement.getElementsByTagName("body").item(0).getTextContent());
}
In the above code, we used the XPath Factory for creating a new instance for the XPath. Then we have taken the XPath for the XML data and stored it as a String datatype. This String expression is called as “XPath Expression”.
Next, we have compiled the list of the XPath Expression by using the xPath.compile() method and iterated the list of nodes from the compiled expression using the evaluate() method.
We have used the getNodeName() method to get the starting element of the XML.
So once the XML document has been read, we would reuse the document and the XPath object in all the methods.
Conclusion
We hope you have found the parser that fits your requirement and in-process also enjoyed reading this article. So to sum things up, we have seen how each parser works to understand the pros and cons of each type. Choosing the apt parser might seem like a very small aspect when compared to the entire scale of the project. But as one of the best software testing service providers, we believe in attaining maximum efficiency in each process, be it small or big.
by admin | Jul 19, 2021 | Automation Testing, Blog, Latest Post |
If you are going to test an application using Selenium WebDriver, you most definitely will face scenarios where you will be needed to trigger keyboard and mouse interactions. This is where our Action Class Guide comes into the picture. Basically, Action Class is a built-in feature provided by Selenium for simulating various events and acts of a keyboard and mouse. With the help of Action classes, you will be able to trigger mouse events like Double Click, Right Click, and many more events. The same goes for keyboards as well, you can trigger the functions of CTRL key, CTRL + different keys, and other such combinations. As one of the best QA companies, we have been able to use Action Class to its zenith by using it in various combinations as per the project needs. But before exploring such Action class implementations, let’s take a look at some basics.
Action Class Guide for MouseActions
So we wanted to start our Action Class Guide by listing some of the most frequently used mouse events available in the Action class.
click() – Clicks on the particular WebElement (Normal Left Click)
contextClick() – Right clicks on the particular WebElement
doubleClick() – Performs a double click on the WebElement
dragAndDrop (WebElement source, WebElement target) – Clicks and holds the web element to drag it to the targeted web element where it is released.
dragAndDropBy(WebElement source, int xOffset, int yOffset) – Clicks and Drag the element to the given location using offset values
moveToElement(WebElement) – Moves the mouse to the web element and holds it on the location (In simple words, the mouse hovers over an element)
moveByOffset(int xOffSet, int yOffSet) – Moves the mouse from the current position to the given left (xOffset value) and down (yOffset Value).
clickAndHold(WebElement element) – Clicks and holds an element without release.
release() – Releases a held mouse click.
Action Class Guide Keyboard Actions
Same as above, we have listed some frequently used keyboard events available in the Action class,
keyDown(WebElement, java.lang.CharSequence key) – To press the key without releasing it on the WebElement
keyUp(WebElement, java.lang.CharSequence key) – To release the key stroke on the webElement
sendkeys(value) – To enter values on WebElements like textboxes
So by including these methods, you can smoothly run your script and execute the code without any issues….
Absolutely not, we’re just kidding. We still have to gather all the action methods and execute them under the Action class.
build() – It is a method where all the actions are chained together for the action which is going to be performed.
So the above method can be used to make the actions that are to be executed ready.
perform() – It is a method used to compile and also execute the action class.
A perform method can be called alone without a build method to execute the action class methods if only one action is performed.
Action Class Guide for Performing actions
Now that we have gone through the basics, let’s find out how to implement the Action Classes in Code.
Step1:
Import the Interaction package that contains the Action Class. You can use the below line for importing,
“importorg.openqa.selenium.interactions.Actions; ”
Step2:
Create the object of the Action Class and use the Web Driver reference as the argument
Actions action = new Actions (driver)
Step3:
Once the above two steps have been completed, you can start writing your script using the Action classes and the different methods available.
Let’s proceed further and take a look at the implementation and uses of the actions available for both the mouse & keyboard.
1. SendKeys(WebElement element, value)
As stated above, this action class is mainly used to send a char sequence into the textbox. But it is also worth noting that we can use it to send the keystrokes of different key combinations likeCTRL+T, Enter, and so on.
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import java.util.concurrent.TimeUnit;
public class SendKeys {
public static void main(String[] args) {
WebDriver driver; System.setProperty("webdriver.chrome.driver","D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.flipkart.com/");
driver.manage().window().maximize();
Actions action = new Actions(driver);
WebElement eleSearchBox = driver.findElement(By.cssSelector("input[placeholder='Search for products, brands and more']"));
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
action.sendKeys(eleSearchBox, "Iphone").build().perform();
action.sendKeys(Keys.ENTER).build().perform();
driver.close();
}
}
By using the SendKeys method, an element is searched by the keystroke instead of clicking on the Search Button. (i.e.) We can clearly see in the code that the “Keys.Enter” is inside the Keys class that has various keystrokes available for the keys.
2. MoveToElement(WebElement element)
You might be in a position to test if an element changes color, shows some additional information, or performs the intended action when the mouse hovers over it. So let’s take a look at the code and find out how you can make it happen.
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.util.concurrent.TimeUnit;
public class MouseHover {
public static void main(String[] args) {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://www.leafground.com/");
driver.manage().window().maximize();
Actions action = new Actions(driver);
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollBy(0,170)", "");
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
new WebDriverWait(driver, 20).until(ExpectedConditions.elementToBeClickable(By.xpath("//img[@alt='mouseover']"))).click();
WebElement eleTabCourses = driver.findElement(By.xpath("//a[normalize-space()='TestLeaf Courses']"));
action.moveToElement(eleTabCourses).build().perform();
driver.close();
}
}
We have written the above code in a way that the code first waits for the image to become clickable. Once it loads, the image gets clicked, and the mouse hovers over the element for a second.
3. DragAndDrop(source, target)
So there are basically two types of drag and drop that we will be seeing in this Action Class Guide. This is the type of action class using which we can assign a target area where the element can be dragged and dropped. Now let’s see the code to execute the DragAndDrop action,
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import java.util.concurrent.TimeUnit;
public class DragAndDrop {
public static void main(String[] args) {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://www.leafground.com/");
driver.manage().window().maximize();
Actions action = new Actions(driver);
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
driver.findElement(By.xpath("//h5[normalize-space()='Droppable']")).click();
WebElement eleSource = driver.findElement(By.xpath("//div[@id='draggable']"));
WebElement eleTarget = driver.findElement(By.xpath("//div[@id='droppable']"));
action.dragAndDrop(eleSource,eleTarget).build().perform(););
driver.close();
}
}
For dragging an element to the dropped place, first, the locators are captured for the source and target. Following this, they are passed inside the action method using dragAndDrop.
4. DragAndDropBy(WebElement source,int xOffset, int yOffSet )
So we have already seen how to drag a drop an element within a targeted area, but what if we would like to drag and drop an element by a defined value? Let’s take a look at the code and find out how.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import java.util.concurrent.TimeUnit;
public class DragAndDropOffset {
public static void main(String[] args) throws InterruptedException {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://www.leafground.com/");
driver.manage().window().maximize();
Actions action = new Actions(driver);
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
driver.findElement(By.xpath("//img[@alt='Draggable']")).click();
WebElement eleDrag= driver.findElement(By.xpath("//div[@id='draggable']"));
action.dragAndDropBy(eleDrag,200,130).build().perform();
Thread.sleep(2000);
driver.close();
}
}
In the above code, we have used the DragAndDropBy method in a way that it clicks and moves the element to the offset position as specified and releases it once the target location is reached.
5. Click(WebElement element)
There is no way to test anything without being able to use the left click button. So let’s find out the code to execute this very basic and necessary functionality.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
public class LeftClick {
public static void main(String[] args) {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.google.com/");
driver.manage().window().maximize();
Actions actions = new Actions(driver);
WebElement eleInput = driver.findElement(By.name("q"));
actions.sendKeys(eleInput, "www.codoid.com").build().perform();
WebElement BtnSearch = driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']"));
actions.click(BtnSearch).build().perform();
driver.close();
}
}
6. ContextClick(WebElement element)
Though the right-click is not used as commonly as the left click, it is still a very basic functionality every tester must know. So let’s take a look at the code to find out how to implement it.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import java.util.concurrent.TimeUnit;
public class RightClick {
public static void main(String[] args) {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://demo.guru99.com/test/simple_context_menu.html");
driver.manage().window().maximize();
Actions action = new Actions(driver);
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
WebElement eleRightClick = driver.findElement(By.xpath("//span[@class='context-menu-one btn btn-neutral']"));
action.contextClick(eleRightClick).perform();
driver.close();
}
}
It is worth mentioning here that we have not used ‘build’ anywhere in the above code. Instead, we have used ‘perform’ to execute the functionality.
7. DoubleClick(WebElement element)
Just like the previous functionalities we have seen in the Action Class Guide, double-click is another basic functionality that is vital to any form of testing. So let’s jump straight to the code.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import java.util.concurrent.TimeUnit;
public class DoubleClick {
public static void main(String[] args) {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://demo.guru99.com/test/simple_context_menu.html");
driver.manage().window().maximize();
Actions action = new Actions(driver);
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);
WebElement eleDoubleClick = driver.findElement(By.xpath("//button[normalize-space()='Double-Click Me To See Alert']"));
action.doubleClick(eleDoubleClick).perform();
driver.quit();
}
8. KeyDown(WebElement element, Modifier Key) & KeyUp (WebElement element, Modifier Key)
CTRL, SHIFT, and ALT are few examples of modifier keys that we all use on a day-to-day basis. For example, we hold down Shift if we want to type something in caps. So when we use the KeyDown action class, it holds a particular key down until we release it using the KeyUp action class. With that said, let’s see an example code in which we have used these functionalities,
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
public class KeyDownAndKeyUp {
public static void main(String[] args) {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.google.com/");
driver.manage().window().maximize();
Actions actions = new Actions(driver);
WebElement eleInput = driver.findElement(By.name("q"));
actions.click(eleInput).build().perform();
actions.keyDown(eleInput, Keys.SHIFT);
actions.sendKeys("eiffel tower");
actions.keyUp(eleInput,Keys.SHIFT);
actions.sendKeys(Keys.ENTER);
actions.build().perform();
driver.close();
}
}
So if you have taken a look at the code, it is evident that once we have used the KeyDown method, the Shift key was pressed down. So the text ‘eiffel tower’ that was fed in the next line would have gotten capitalized. Now that the KeyDown has solved its purpose in this scenario, we have used to KeyUp method to release it.
9. MoveByOffset(int xOffSet, int yOffSet)
As seen above, ByOffset(int x, int y) is used when we need to click on any particular location. We can do this by assigning locations for the x and y axes. Now let’s explore the code that we have used for execution.
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
public class MoveByOffSet {
public static void main(String[] args) throws InterruptedException {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.google.com/");
driver.manage().window().maximize();
Actions actions = new Actions(driver);
WebElement eleInput = driver.findElement(By.name("q"));
actions.sendKeys(eleInput, "Eiffel").build().perform();
actions.sendKeys(Keys.ENTER).build().perform();
Thread.sleep(2000);
actions.moveByOffset(650, 300).contextClick().build().perform();
driver.close();
}
}
10. ClickAndHold(WebElement element)
The action method that we will be seeing now in our Action Class Guide can be used when an element has to be clicked and held for a certain period of time.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
public class ClickAndHold {
public static void main(String[] args) throws InterruptedException {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.google.com/");
driver.manage().window().maximize();
Actions actions = new Actions(driver);
WebElement eleInput = driver.findElement(By.name("q"));
actions.sendKeys(eleInput, "Flower").build().perform();
actions.moveByOffset(500,300).click().build().perform();
Thread.sleep(2000);
WebElement BtnSearch = driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']"));
actions.clickAndHold(BtnSearch).build().perform();
driver.close();
}
}
In the above code, we have first opened Google and then searched using ‘Flower’ as the input and then performed a left-click action at the defined location. After which, we have performed a click and hold action on the search button.
Note:
In addition to that, if we need the click to be released, we can use the release method to release the clicked element before using ‘build’.
actions.clickAndHold(BtnSearch).release().build().perform();
Uploading a File Using SendKeys Method:
We know that the SendKeys action method can be used to send a character sequence. But one interesting way to use it would be to upload a normal document. If you’re wondering how that is possible, let’s take a look at the code,
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
public class FileUpload {
public static void main(String[] args) throws InterruptedException {
WebDriver driver;
System.setProperty("webdriver.chrome.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("http://www.leafground.com/");
driver.manage().window().maximize();
driver.findElement(By.xpath(" //img[@alt='contextClick']")).click();
WebElement eleSendFile = driver.findElement(By.cssSelector("input[name='filename']"));
eleSendFile.sendKeys("C:\\Users\\OneDrive\\Desktop\\Sample.txt");
Thread.sleep(2000);
driver.close();
}
}
In the above code, we have used the SendKeys action method to enter the file’s address path to locate the object that has to be uploaded. The document which we have used here is an input type document as this type of document is only ideal for sending the document using SendKeys.
Note:
Just in case you are not using Google Chrome and would like to execute these action class methods in Mozilla Firefox, all you have to do is just add the driver and set the system property for the gecko driver and initialize the driver object for it using the below line.
System.setProperty("webdriver.gecko.driver", "D:\\ActionClass\\src\\test\\java\\Drivers\\geckodriver.exe");
driver = new FirefoxDriver();
Conclusion:
We hope you have enjoyed reading our introductory action class guide that has covered the basic action class methods starting from a basic ‘Click’ to uploading a file using ‘SendKeys’. Action class helps one to perform all the basic actions on a webapp.Release() method, which can be used to release any element that was clicked or held. ‘Perform’ can be used alone, but if there are more composite actions, build and perform should be used together. As a leading test automation company, we are well aware of how resourceful action classes can be when used effectively. Once you have understood the basics, you would be able to perform so many more actions by using combinations of the action methods established in this blog.
by admin | Jul 13, 2021 | API Testing, Blog, Latest Post |
Postman is an API (Application Programming Interface) development tool that allows users to perform GET, POST, PUT, DELETE, and many other requests to the web service API. Postman allows you to manually test your APIs in both its desktop and web-based applications. However, it also has the ability to automate these tests by writing JavaScript assertions on your API endpoints. As one of the best QA companies, we always thrive on using the best tools for our projects, and Postman has become one of our go-to tools when it comes to API testing. So in this Postman Guide, we will be exploring how to perform the above said requests like Post, Request, and so on. But before we proceed further, let’s have a brief introduction to API testing.
What is API Testing?
API testing is a type of software testing where application programming interfaces (APIs) are tested to determine if they meet the expected functionality, reliability, performance, and security levels. It only concentrates on the business logic layer of the software architecture.
Some of the important components in Postman
Users will be able to write a script to manipulate the data being sent with the request. The pre-request script will run before the request is sent.
This is the test editor where the users can configure the test cases that are being validated once the request has been fulfilled.
The environment in postman is a set of key-value pairs which is used to set dynamic values.
A group of requests will be displayed under collections, and it can be used to organize and keep track of related requests.
Postman Guide to create & run the First API Request:
First and foremost, we have to create a new workspace and click on the New option under ‘File’, and then select ‘Request’.
Enter the name as ‘GET Request’ and then click on + NEW COLLECTION. Following which we will be able to assign a suitable name for the collection.
Once we click on Save, the collection name will be displayed with your API in it. Now that we have prepped everything, let’s make the first API call by following the below steps,
We have to enter the URL in the address bar and click on the ‘Send’ button to see the response.
The response will include details such as the status code, time, size, headers, and cookies alongside the Body.
Status Code
So if you take a look at the above image, the HTTP status code is shown to be “200 OK”, which means that everything has worked as expected and that our request is successful.
Time
Right beside the status code, we can see that the time taken to complete the request is 509 ms.
Size
The other available parameter is the size of the requested data, we can see that size is mentioned to be 1.92 KB in the above image.
Note:If we hover the mouse over the time and response values, we will be able to view more details
To save this response, we can simply click on the ‘Save Response’ option.
As stated above, we can also see the body, which is an HTML file in the image. Clicking on the ‘Preview’ option under the body will enable us to view the body in HTML format.
We can click on ‘Cookies’ to view the session-related information and on ‘Headers’ to view other details such as date, content type details, etc.
So by following the above instructions, we have successfully made our first request! Now let’s find out how to send a post request in Postman.
Postman Guide to send a Post Request:
Post is one of the HTTP methods that can be used to add new resources like a webpage and so on. So if we want to create and add a new user to the database, we can utilize the Post request. Likewise, we can also use Post requests for form submissions, authentication requests, and so on.
Let’s see how Post request works:
In Postman, we have an endpoint that responds back whenever we send a request. So, now we are going to send a particular key-value pair in the JSON format to a server.
First, we have to set the HTTP Method to POST.
Next, we have to mention the URL in the address bar.
In the Body tab of the request editor, we should select the ‘Raw’ option and then select JSON from the dropdown list.
We have chosen Raw with JSON as it is one of the most commonly used Post Requests.
So enter the REQUEST in the Body and click on ‘Send’.
We can see that the user has been created in the above image. In addition to that, we also have the same type of information that we saw earlier that includes status code, time, and so on.
But this time around, we have the status code displayed as 201, which implies that the request has been created.
Click on ‘Save’ to save this request.
‘POST REQUEST’ can be used to add a set of data into the server database. But it is crucial to make sure that the fields are filled with the correct data type, as any incorrect data will result in a 400 Bad Request.
Postman Guide to send a DELETE Request:
Previously, we saw how to send a post request in which we created a user and sent a body. Now let’s see how we can delete a request in Postman. We can use the DELETE HTTP Method to delete an existing record of a user in a database. The expected response in the Status for this is 204.
So primarily, we would have to set the HTTP Method to DELETE, then mention the URL in the address bar, and also mention the final endpoint.
Once the above actions have been completed, we can go ahead and click on ‘Send’.
So as expected, we have the Status Code shown as 204, which denotes that the particular resource has been deleted.
But what if the user has some additional parameters? We can pass query parameters and add them to the body section for deleting those resources as well.
Collections
Collections are nothing but a group of requests grouped into a folder. The simplest example of this would be the way we organize the files on our computers or mobile phones. Let’s say we have multiple files of different formats like text files, audio files, video files, etc. We most probably would create new folders and segregate all the files based on their format.
In the same way, we can create different groups using POSTMAN, and each group can have its own type of request. In addition to having the option to create a collection, we will also be able to share this collection with the team members and encourage healthy collaboration. The other advantage is that since we can share the collection, we will also be able to perform various actions like assigning roles, documentation, mock servers, monitors, etc.
Postman Guide to create a collection:
Now that we have seen the purpose of collection, let’s find out how to create one by making use of the following steps.
Click on the ‘New‘ option, then click on ‘Collection’, and enter the Collection Name. We will be able to click on ‘Create’ once we have also added the description of the collection.
Now we can see that we have several options like Run, Share, and so on displayed.
Here we can click on ‘Add Requests’, or replace any existing requests.
Once we click on ‘Run’, a new window will be opened, enabling us to run the collection by clicking on ‘Run My Collection’.
So now we are able to see results for all the requests under the collection, making it evident that we can save an ample amount of time by running multiple requests at a time.
We can click on the ‘Run Again’ option to rerun the collection. Following this, we can click on ‘Export Results’ to export the results as a JSON file. If you take a look at the below image, we can understand that it can be downloaded as well.
Different features of collections
• We can add the collections to favorites.
• It helps users share & assign the roles, create fork & pull requests, and also merge changes.
• We can create a duplicate of collections and export them.
Environment in Postman
It is very important to create distinct environments where one is dedicated for testing, one for development, and another for production. An environment is nothing but a set of variables or key-value pairs which we can be used in our requests. We can also change the value of the variables to pass the data between requests and tests. But how we do create an Environment? Let’s find out.
Postman Guide to create an Environment:
1. First, we have to click on the ‘Environments’ option.
2. Then we have to click on the ‘Add’ icon.
3. We can now enter the Environment name.
4. Followed by which we can enter the variable name to use it with the request.
The initial value is shared with your team when you share the variable in a collection as it will be shared with the collaborators who have access to the environment.
The current value is always used when a request is sent as they are never synced to Postman’s servers. If left untouched, the current value will automatically be assumed as the initial value.
Click on ‘Add’ to create the environment. Once the environment has been created, users can share, copy or even download them if needed.
Global variables in Postman
Global variables allow users to access data between collections, requests, test scripts, and environments. Global variables are not dependent on any environment, making them available for all the requests. They are available throughout the workspace. But on contrary, local variables are available only in particular environments.
When to use Global and Local Variables
When we have multiple key-value pairs which do not depend on any environment, we can make them a Global variable.
Local variables can be used when we have key-value pairs which will change or differ between the environments.
Conclusion:
We hope you have enjoyed reading our Postman Guide for API Testing, as Postman is an effective tool when it comes to API testing. We have just seen the tip of the iceberg here, as these are the most important and basic functionalities every tester must know. As a leading test automation company, we have used Postman in various projects and have always been pleased with its performance. So one can always explore the many more useful functionalities that Postman has to enhance their API testing skills.
by admin | Jul 5, 2021 | Selenium Testing, Blog, Latest Post |
Jenkins has become the go-to solution for integrating Selenium with Maven as Jenkins enables quicker deployment and more efficient monitoring. The adoption of the CI/CD pipeline has become more prevalent in the software arena. In addition to being a resourceful DevOps tool, Jenkins is also very effective when it comes to building the CI/CD pipeline. As one of the best QA companies, we have used Jenkins as it helps to check the latest build that can be deployed to the production environment. It also makes the process of Selenium test automation much easier with the help of Maven. So in this Jenkins integration with Selenium guide, we will be going through the step-by-step process on how to do it. Before we proceed further, let’s take a look at a few basics.
An Introduction to Selenium and Jenkins:
Selenium is an open-source automation tool that is widely used for testing web applications across various browsers like Chrome, Mozilla, Firefox, & Safari. Selenium will be able to automate these browsers using Selenium WebDriver. Test scripts can be written in any programming language like Ruby, Java, NodeJS, PHP, Perl, Python, etc.
As stated earlier, we all know Jenkins is an open-source automation tool that allows continuous integration (CI) and continuous delivery (CD) and that it is a java based application. Jenkins is mainly used to build and test any software project, making it easy for developers to continuously work and integrate changes to the project.
Installation of Selenium and Jenkins
Before heading over to the Jenkins integration with Selenium, let’s take a look at how to install and set up both Jenkins and Selenium.
Steps to Download Jenkins
1. Download Jenkins from their official website.
2. Unzip the file and open the Jenkins exe file.
3. Click ‘Next’ to start the installation.
4. Click the Finish button to complete the installation process.
5. You will be redirected automatically to a local Jenkins page, and the port number would be 8080 by default. We can also launch a browser and navigate to the mentioned URL http://localhost:8080
Creating an admin account to access Jenkins
1. You can obtain and enter the secret password by navigating to the mentioned path as shown in the below image. Once you have entered the password, click on Continue.
2. After entering the secret password, you will be asked to install plugins. Click on the required plugins option so that the recommended plugins could be downloaded and installed.
3. After the successful installation, you will be asked to create an administrator account with the following details that are mentioned in the screenshot.
4. Once you have successfully installed Jenkins, the default Jenkins dashboard can be seen as shown below.
Jenkins integration with Selenium
The Jenkins integration with Selenium can be achieved in various ways and we will be focusing on how it can be established using Maven in this guide. Let us quickly introduce what is Maven, why we have chosen Maven, and go through the installation process as well.
What Is Maven?
Maven is a software project management & build management tool which allows us to add and manage all the dependencies in a single pom.xml file.
Why Maven for Jenkins integration with Selenium?
1. It can act as the central repository to get dependencies
2. Maven helps to maintain a common structure across the organization
3. It makes integration with CI tools easier.
How to Install Maven?
1. Download Maven from their official site.
2. Then add MAVEN_HOME under system variables as shown below
3. Now, set up the path for the bin directory of the maven directory.
4. To verify if maven has been installed successfully, type the following command in the command prompt.
5. Post the verification, you can go ahead and create a maven project and add the maven dependencies in the pom.xml file that will be used to achieve Jenkins Integration with Selenium.
POM.xml file
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>MyfirstDemo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.4.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>3.141.59</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
<configuration>
<suiteXmlFiles>
<suiteXmlFile>E:\MyfirstDemo\testng.xml</suiteXmlFile>
</suiteXmlFiles>
</configuration>
</plugin>
</plugins>
</build>
</project>
Using the Java class ‘Sample.java’, we create a WebDriver script. Jenkins Integration with Selenium
package Demo;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;
public class Sample {
@Test
public void demo() {
System.setProperty("webdriver.chrome.driver","src/Drivers/chromedriver.exe");
WebDriver driver = new ChromeDriver();
driver.get("https://www.cricbuzz.com/");
String baseTitle = driver.getTitle();
System.out.println("title =" + baseTitle);
driver.manage().window().maximize();
}
}
TestNG.xml file
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="TestSuite">
<test name="demo">
<classes>
<class name="Demo.Sample">
</class>
</classes>
</test>
</suite>
How To Integrate Selenium Tests In Maven With Jenkins?
So the next aspect that we are going to cover in this Jenkins Integration with Selenium guide is to see how to integrate Jenkins with Selenium WebDriver and how Maven is instrumental in the integration of Jenkins with Selenium test scripts. For a crystal clear understanding, we have also added screenshots of all the important steps.
Start the Jenkins server and launch the browser and navigate to the localhost using the mentioned URL http://localhost:8080.
Steps:
1. The first and foremost step would be to create a new project by choosing the ‘New Item’ option from the Jenkins dashboard.
2. Obviously, the next step would be to give the new project that we have created a name. In this case, we have used “DemoProject” as the name of the project for explanation purposes. It goes without saying that you can name the project as per your wish. Once the name has been entered, we have to select ‘Maven project’ as the option from the given list and then click on OK.
3. The created project file can be seen in the Jenkins dashboard, and so we would have to select the project from the list to proceed further.
4. From the many options that appear on the left, click on ‘Configure’.
5. Automatically Jenkins takes us to the project configuration view where we can configure the project-related details under the General tab. As shown in the image, this section includes the name and description of the project.
6. The next section is the Source Code Management, under which we have to select the ‘None’ option.
The Git Option:
Here, we select ‘None’ in the Source Code Management section as we just need a build.
If you select Git, you would need to commit to the repository and enter the credentials by clicking on ‘Add’. In this Jenkins Integration with Selenium guide, we will be only focusing on the aspects and features needed to make the integration possible.
7. So we can head straight to the Build section next, and it would require two important steps to load the POM.xml file. Under the Root POM, you have to enter the complete path of the pom.xml that you have created. Under the Goals and options, you would have to enter the following command
8. Once these crucial pieces of information have been filled in, we can scroll down and click on ‘Apply’ and then finally ‘Save’.
9. Once the above step is completed, we head back to the project where we have to click the ‘Build Now’ option.
10. Now that we have manually triggered the build in Jenkins, the job will run after the completion of the build.
11. The results can be viewed in the console output as shown below.
Conclusion:
We hope this step-by-step Jenkins integration with Selenium has been helpful to you. Using this integration, we have been able to build and test our software projects efficiently and achieve the goal of continuous integration. Using Jenkins, we have been able to provide the best Selenium testing services to our clients. Beyond the benefits that we have already seen, Jenkins allows us to schedule jobs to run at any time, and it also supports a wide range of selenium plugins that will come in handy to achieve a variety of project needs.
