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.
by admin | Jun 30, 2021 | Agile Testing, Blog, Latest Post |
Testing is essential to produce quality software. Agile approaches aim to integrate quality assurance into product development from the ground level up by having techies heavily involved with testing right from the initial stages. The idea behind this process is that if problems can be identified and corrected earlier in the design process, then the companies will be able to create defect-free products at quicker rates. Most of the agile teams are flying blind without having any proper strategies or measurements to follow. But as one of the best software testing service providers, we have been able to put the agile approach to good effect. So in this Agile Testing Best Practices blog, we will be sharing some important aspects that will help improve your performance in agile testing.
In addition to that, we will also be focusing on the inherent challenges and the many advantages that the agile method brings to the table.
How Agile testing is different from traditional testing:
Agile testing is a core part of the agile software development process. It is also very different from the conventional testing methods. Traditional testing is done in a phased manner so that the end-product doesn’t get released until all the defects have been fixed. But on the contrary, agile testing follows an iterative approach. So defects are fixed in each sprint and released right away. Testers define the success or failure of the team’s attempts to be agile as they are a part of the delivery team, making them an integral part of any agile team. So the adaptability of testers in SDLC is very important in the agile approach.
Five things make agile testing different from traditional testing, and they are
- Continuous Involvement
- Essential Tools
- Multidimensional Skills
- Effective Communication
- Quick Feedback from Testing
Agile Testing life cycle:
1. User Story Analysis,
It is important to understand the release plan and plan the user stories across the sprints in a release.
2. Test plan / Estimate,
It gives the ability to have all the high-level scenarios, requirements, and estimates in one plan. It is created for each release, and it should also be updated for every release.
3. Sprint Planning,
The purpose of sprint planning is to define what should be delivered in a sprint and how that can that be made possible. The team assembles together to achieve the required velocity of the sprint.
4. Environment Setup,
Agile is a process that requires consistent teamwork and the work environment plays a huge factor in encouraging the team to work towards a common goal. So nurturing such an environment is one of the vital agile testing best practices that can make a difference. This can be accomplished by valuing each individual & their ideas and by healthy collaboration as the process demands frequent changes.
5. Implementation and Execution,
The creation of test cases across the assigned user stories and peer review is performed in this stage. For better quality deliverables, developers can take a look at these test cases and ensure that the overall scenarios have been enlisted. The distribution of various tests based on risk analysis is vital. So test cases must comprise of all test types like Functional, UI, Usability, cross-browser, etc. So once the test cases have been created, we have to ensure if the stories are ready for testing and execute the created test cases.
6. Defect Reporting,
The ultimate point of any form of software testing is to identify the bugs and report them so that they can be fixed. So it is important to devise an efficient method to report all the encountered bugs in an effective bug management tool. Healthy real-time collaboration with the developers can be achieved only when the defect log contains information like summary, description, priority, date of identification, steps to reproduce, name of the tester, unique identifier, etc. Such an in-depth report will enable us to conduct a triage meeting to plan and fix the bugs that have been logged.
7. Release Activity,
Once we are past all the above stages, the build can be deployed for UAT where testing can be performed with a few users. If the build clears the smoke tests that will be performed by the alpha testers, then the release can be given to the beta testers who will test the build before signing it off from their end and ship it to production.
8. Getting ready for the next release,
After the release, the team should prepare for their next release. Any and all business clarifications or issues should be raised and cleared during this phase.
The Quadrants for Agile Testing Best Practices
Agile testing can be simplified by using a system of quadrants that provides necessary classifications that determine which type of test should be run, how often it should be run when it should be run, and who it should be run by. Since there are so many types of testing like acceptance testing, regression testing, unit testing, and so on. Quadrants help reduce the difficulty in deciding which test has to be used where. It will also answer the question of whether manual or automated testing is better suited for the current iteration of the product.
So, now let’s find out how quadrants work their magic. Quadrants divide the whole testing methodology into four grids. These 4 grids help the whole team to communicate and deliver the quality product on time.
Quadrant Q1 – The tests in the first quadrant are unit level, technology facing, and also supportive to the developers. Unit tests and other component level tests that test the code belong to this quadrant. In general, the tests in this quadrant are automated.
Quadrant Q2 – The second quadrant consists of tests that are system level, business-facing, and help conform product behavior. Functional tests belong to this quadrant. These tests can either be manual or automated.
Quadrant Q3 – The tests in this quadrant are system or user acceptance level, business-facing, and focused on real-time scenarios. User Acceptance Tests belong to this quadrant. These tests are manual.
Quadrant Q4 – The tests in the final quadrant are system or operational acceptance level, technology facing, and focus on performance, load, stress, maintainability, and scalability. Special tools can be used for these tests, along with automation testing.
Agile Testing Best Practices to Overcome Challenges:
Let’s take a look at some of the most common challenges that agile teams will face during testing and see how we will be able to overcome them as well.
Last-minute changes:
Changing requirements is an inherited challenge of the agile methodology. This means that even if a work is already completed or half done, it might have to go through some modifications or worst-case scenario, get scrapped as well. So this will most definitely will have an unexpected change in the scope of testing.
How to master?
Testers must be ready to react to the changes or modify the processes in agile methodology as the process is itself prone to changes. Whenever there is a change in the requirements, testers should share the information of what tests they have actioned and which part of the application they have not yet tested. This can help the team understand how to make the required changes.
Not Enough Information (one-line stories):
Sometimes product owners will just have an idea of what features are required. So business owners may not even be aware of the specific requirements. In such situations, testers will not have a good set of details about the user stories at their disposal. All they might have could be just single-line information which is insufficient to build comprehensive test cases. This causes a significant amount of hindrance to the testers.
How to master?
In this situation, the testers can collect all the minutes of each requirement before they start testing and they can even come up with high-level scenarios for the stories and confirm them with the author or product owner and then approach the test cases.
Lack of Communication:
Without effective communication between developers, testers, and the product owner no process can work. So effective communication is also one of the most important agile testing best practices. Lack of communication can result in different teams flying blind with no proper goal as to what should be accomplished.
How to master?
Daily standup meetings with the team are strongly encouraged. It is also important to make sure that the meetings are not too long. Daily standups help identify roadblocks and solve them on a day-to-day basis. It also helps to keep the developers and product owners on the same page as the rest of the team.
Frequent regression testing:
As features get pushed by developers continuously, testers would have to run regression tests very frequently as the chances of the new features breaking the previous code are much higher. The other major challenge is that testers would have to test the application’s functionality correctly for all the users. Testers would also have to check the application’s behavior on different devices.
How to master?
Automation skills can be a great help for this situation in agile projects. Automating the regression test can save you a lot of time, and Selenium is the most popular browser automation tool that might solve all your needs. Apart from that, testers can use tools like Docker or VisGrid to run their automated test scripts in parallel across various browsers and devices.
Technical Skills:
As software becomes more mature, the complexity increases along with it as well. Testers should be in a position to help developers with API testing, integration testing, and more. So having strong technical skills is one of the basic requisites of a tester who is working in agile.
How to master?
Being in the process of continuous learning always helps people excel in their respective fields. Likewise, testers can learn programming languages like Java, Python, C#, etc., and learn automated testing tools like Selenium, JMeter, and so on. It is also crucial for the team to comprise dedicated testers with professional experience. If you are looking for the best agile testing tools, then you could read our blog and explore your options.
Conclusion:
We hope you have enjoyed reading this blog and that it has been informative as well. These agile testing best practices have helped us deliver the best software testing services to our clients, and hope it will enhance your testing methods as well. Obviously, these tips alone will not equip you to face any challenge that comes your way. But these general tips will definitely help you overcome the regular challenges and also help you find the right solutions for every new challenge you would face.
by admin | Jun 21, 2021 | Automation Testing, Blog, Latest Post |
TestNG is not the only option available in the market. But most of the automation testers prefer TestNG over other options like JUnit because TestNG allows parallel execution of test cases that saves loads of time possible with the help of the ‘parallel’ keyword in the XML file, TestNG’s seamless integration with tools like Jenkins, Maven, etc., and grouping of test cases also becomes easy with the use TestNG. These features have been instrumental in us providing the best software testing services to our clients. So in this TestNG tutorial, we will be focusing on how to make use of all these advantages and also explore all the advantages that TestNG brings to the table.
TestNG is an open-source testing framework where NG stands for Next Generation. It provides many features to execute the test methods by using various annotations like @Test @BeforeTest, @BeforeClass, etc. TestNG allows its users to generate robust test results that include the number of test cases that have Run, Passed, Failed, and Skipped. It can also be used to implement the logging feature using TestNG Listeners. On the whole, TestNG can also be used across various testing types like Unit, Regression, Functional, and API Testing. But before we get started with the TestNG Tutorial, let’s see how to set it up.
Installation and Setup of TestNG in IntelliJ:
IntelliJ requires a JAR file to add dependencies for TestNG script development and for running the test suites. So if it is a Maven Project, we would have to download the TestNG Jar File. Since we will be running tests on Java, we need to download an external TestNG Jar File onto our system by using the provided link.
Direct download link: TestNG/7.4.0/testng-7.4.0.jar
Reference: org.testng/TestNG
Please refer to the below image and instructions for a step-by-step guide,
i. Open IntelliJ,
ii. Create a new JAVA Project,
iii. Navigate to ‘File’ >> ‘Project Structure’ in IntelliJ,
iv. Click on ‘Libraries’ from Project Setting,
v. Add it to your ‘TestNG’ jar file, and then click on the ‘Apply and OK’ button.
If we want to work on a maven project, we have to mention the dependency in the POM.xml file
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.4.0</version>
<scope>test</scope>
</dependency>
TestNG Annotations:
TestNG annotations that are used to execute the test scripts can be defined by ‘@Test’ annotations. Before we head over to other aspects of the TestNG Tutorial, let’s take a look at the various annotations that are available in TestNG along with a short description of them.
Types of TestNG Annotations:
@Test Annotations:
We use this annotation to mark a method as a test method. The methods marked with @Test annotation are automatically invoked by the TestNG engine in default order (i.e.) alphabetically.
Syntax:
@Test
public void TestMethod1() {
System.out.println("\n Test-Method-001");
}
So in this part of the TestNG Tutorial, we will be focusing on the most important attributes of @Test annotations, starting with the description
1. ‘Description’ attribute of @Test Annotation:
The ‘Description’ keyword is used to provide a description of the test case. It can also be termed as a one-line summary, and it has been illustrated in the below example that describes the action of the user in a single line.
@Test(description = "User visits Codoid Home page")
public void launchCodoidURL(){
System.out.println("\n >>> User visits Codoid Home page...");
}
2. Test Methods with Priority:
As mentioned earlier, we are aware that the methods will execute multiple test annotations alphabetically by default. But what if there is a need to run the methods or the test annotations based on defined priorities? Here is where the ‘Priority’ attribute comes into play, as it can be used to assign priorities to each test method. The highest priority would be given when a test method is marked with 1 and the priority decreases inversely as the number increases.
We have mentioned syntax below to denote how the priority attribute would function.
Syntax:
@Test(priority = 1)
public void Test1() {
System.out.println("\n Test-1");
}
@Test(priority = 2)
public void Test2() {
System.out.println("\n Test-2");
}
3. Test Methods with Priority & without priority:
So in the above-mentioned syntax code, we saw 2 sets of programs that had defined priorities. But what if there is a need to define priorities only for a certain number of methods? It is very easy to accomplish as you can simply leave the methods that don’t need defined priorities and mark the other methods alone in the order that you wish. It is worth noting that the methods that had no defined priority will be run first on an alphabetical basis and then followed by the defined order.
Syntax:
@Test(priority = 1) //with Priority
public void Test1() {
System.out.println("\n Test-1");
}
@Test //without priority
public void TestMethod1() {
System.out.println("\n Test-Method-001");
}
@Test //without priority
public void TestMethod2() {
System.out.println("\n Test-Method-001");
}
@Test(priority = 2) //with Priority
public void Test2() {
System.out.println("\n Test-2");
}
Code Explanation:
– Non-Prioritized methods ‘TestMethod1() and TestMethod2()’ have been executed in alphabetical order. (Line No: 60 and 65)
– Prioritized methods ‘Test1() and Test2()’ have been executed based on the priority level. (Line No: 55 and 69)
4. Depends On Methods in TestNG:
In our test scripts, we might have some methods that depend on the execution of another method before it is executed. For example, if a user wishes to send an email using the email application, then the user has to be logged in to the application first. So there will be no point in trying to send the mail if the sign-in is incomplete. So we can make use of this attribute that will help methods from getting executed if their dependent method doesn’t get a ‘Pass’. The same scenario is shown below as an example.
Syntax:
@Test
public void UserLoginIntoEmailApplication(){
System.out.println("\n >> User Login :: ");
}
@Test(dependsOnMethods = "UserLoginIntoEmailApplication")
public void UserSendAnNewEmail(){
System.out.println(">> User send an eMail");
}
Sometimes, there might be scenarios where a test case depends on more than one test method. So we can pass the parameters in annotations as shown below.
Syntax for dependsOnMethods: (Multiple Dependent Test methods)
@Test(dependsOnMethods = { "UserLoginIntoEmailApplication", "UserSendAnNewEmail" })
public void SignOut() {
System.out.println(">>> Sign Out");
}
5. TestNG Groups:
The grouping concept is one of the best features of TestNG and one of the important parts of this TestNG Tutorial. So using this concept we can create a group of test methods based on modules/test cases. For example, the client requirement might demand you to execute a large number of smoke or regression tests. So you can simply pass the parameter in group attributes as shown below.
Syntax:
@Test(groups = { "Regression" })
public void userLogin() {
....
}
@Test(groups = { "Regression" })
public void userSendEmail() {
....
}
So the groups are specified in the ‘.xml’ file and can either be used with the “groups” tag name or under the ‘test’ tag.
Syntax:
<groups>
<run>
<include name = "Regression"></include>
</run>
</groups>
DataProvider in TestNG:
In this method, a user will be able to pass the test data in test methods and also iterate the test methods using different data from the @DataProvider annotation, and it will return the 2D array objects.
Let’s see a simple example for this annotation,
Code:
@DataProvider(name = "data-provider")
public Object[][] dataProviderMethod() {
return new Object[][]{{"Codoid-001"}, {"Codoid-002"}};
}
@Test(dataProvider = "data-provider")
public void testDataProviderConcept(String strData) {
System.out.println("\n >> Data: " + strData);
}
Code Explanation:
We have maintained the array object and Test methods in the same class. In this method, the “testDataProviderConcept(String strData)” will iterate based on the array size. It will also retrieve the values “Codoid-001 and Codoid-002” from the ‘dataProviderMethod()’ with the help of the @DataProvider annotation.
Multiple Parameters in TestNG DataProvider:
It is even possible to pass multiple data through a single parameter. In this test method, we will be able to retrieve the data using multiple arguments as shown in the example,
For example,
@DataProvider(name = "data-provider")
public Object[][] dataProviderMethod(){
return new Object[][] {{123,456 ,789}, {001, 002, 003}};
}
@Test(dataProvider = "data-provider")
public void testMethod(int value1, int value2, int value3) {
System.out.println("\n >> value1: "+value1+"; Value2: "+value2+"; Value3: "+value3);
}
DataProvider In TestNG Using Inheritance concept:
If you are looking for a way to maintain the code based on the project structure, then the DataProvider methods can maintain one class and the test methods can maintain another class. Let’s take a look at the example to find out how.
For example, we can access the dataprovider class using another attribute like “dataProviderClass”
Syntax :
@Test(dataProvider = “data-provider”, dataProviderClass = DP.class)
Note:
i. dataProviderClass // attribute Name
ii. DP.class // class Name; To inherit the other class.
Code:
//Class-1
@Test(dataProvider = "data-provider", dataProviderClass = DataProviderUtil.class)
public void testDataProviderConcept(String strData) {
System.out.println("\n >> Data: " + strData);
}
//Class-2 "Class Name: DataProviderUtil"
@DataProvider(name = "data-provider")
public Object[][] dataProviderMethod() {
return new Object[][]{{"Codoid-001"}, {"Codoid-002"}};
TestNG Tutorial for using Excel Workbook as a Data Provider:
Now that we have seen how to pass the parameter with single or multiple data through an array object, but what if there is a need that demands a large number of data be used? Adding everything to the code will not be an optimal choice at all. We have a solution to overcome this in our TestNG Tutorial and so let’s focus on how we can retrieve data from an Excel workbook. Knowing this will come in very handy while executing Functional tests, and when there is a need to create a large amount of test data for performing Load tests.
We are going to implement the Excel workbook in the TestNG-DataProvider annotation to fetch the data from the excel sheet and search the products in Amazon. In the example, we have listed a few mobile phones like iPhone 12, Pixel 4a, and so on in the excel sheet.
The below-mentioned Excel util class is used to retrieve the data from the Excel sheet.
ExcelUtil.JAVA
Code:
/*Description: We can retrieve the data from the Excel workbook
* parameter-1: Excel workbook directory path,
* parameter-2: Sheet name*/
public static Iterator<Object[]> getTestData(String strWorkbookPath, String strWorksheetName) {
List<Object[]> data = new ArrayList<Object[]>();
int inRowCounter = 0;
try {
FileInputStream file = new FileInputStream(new File(strWorkbookPath));
//Get the workbook instance for the xlsx file.
HSSFWorkbook workbook = new HSSFWorkbook(file);
//Get the first sheet from the workbook
HSSFSheet sheet = workbook.getSheet(strWorksheetName);
//Get an iterator to all the rows in the current sheet
Iterator<Row> rowIterator = sheet.rowIterator();
Row firstRow = rowIterator.next();
Map<String, String> columnNamesMap = getColumnNames(firstRow);
while (rowIterator.hasNext()) {
Iterator<Cell> cellIterator = rowIterator.next().cellIterator();
Map<String, String> rowMap = new LinkedHashMap();
for (Entry entry : columnNamesMap.entrySet()) {
String strColumnName = entry.getKey().toString();
String strValue = cellIterator.next().toString();
rowMap.put(strColumnName, strValue);
}
}
file.close();
} catch (Exception e) {
e.printStackTrace();
}
return data.iterator();
}
private static Map<String, String> getColumnNames(Row row) {
Map<String, String> columnNamesMap = new LinkedHashMap();
Iterator<Cell> cells = row.cellIterator();
while (cells.hasNext()) {
String strColumnName = cells.next().toString();
columnNamesMap.put(strColumnName, strColumnName);
}
return columnNamesMap;
}
DataProvider.Class
@DataProvider(name = "AmazonProduct", parallel = false)
public static Iterator<Object[]> getDeviceName() {
String strWorkBookPath = new StringBuilder().append(System.getProperty("user.dir")).append(File.separator)
.append("resources\\testdata").append(File.separator).append("testdata").append(".xlsx").toString();
Iterator<Object[]> testData = ExcelUtil.getTestData(strWorkBookPath, "Mobiles");
return testData;
}
TestScripts.java
@Test(dataProvider = "AmazonProduct", dataProviderClass = DataProviderUtil.staticProviderClass.class)
public void searchAmazonProducts(Map<String, String> dataMap) {
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.amazon.in/");
wait = new WebDriverWait(driver, 25);
WebElement txtSearchEngine = wait.until(ExpectedConditions.visibilityOfElementLocated(
By.cssSelector("#twotabsearchtextbox")));
System.out.println("\n Devices : " + dataMap.get("Devices"));
txtSearchEngine.sendKeys(dataMap.get("Devices"));
txtSearchEngine.submit();
driver.quit();
}
Please refer to the below image,
Parameterization in TestNG:
When there is a need to perform tests by using different test data, or when you are looking to test by logging in with a different user that has distinct usernames and passwords then Parameterization will come in handy as the “@Parameters” annotation in TestNG allows argument values to pass to Test methods via the testng.xml file. (Parameter values are declared in testng.xml) We have explained the different user scenarios using an example.
Syntax:
@Parameters({ “param-name” })
Let’s write a simple program for the @Parameters annotation,
Code:
@Test
@Parameters({"Username"})
public void TestMethod1(String strUsername) {
//We can retrieve the data using this argument. (It’ll retrieve from testng.xml file)
System.out.println("\n Username : " + strUsername);
}
TestNG Tutorial for Parallel Execution:
Saving time during the testing process is always a priority, and one of the best possible ways to do it would be by executing tests in parallel rather than sequential execution. So as promised at the beginning of this TestNG Tutorial, let’s see how we can have test suites executed in parallel on different browsers, and how it can be even defined in the Testing.xml file.
TestNG provides different levels of execution that we can achieve by using the Testing.xml file. The attributes that we can use to achieve them are,
i. Methods,
ii. Classes, and
iii. Tests.
i. parallel=”methods”:
We had already seen about methods that are dependent on other methods for their execution, so accordingly if you are looking to execute many independent methods in parallel, then this attribute can be used. Using this attribute, all test methods will run on a separate thread. In the below example, we have executed two test methods in two threads.
Note: Thread count is the specified number of browser instances that should be assigned for this test execution.
Syntax:
<suite name="Test-method Suite" parallel="methods" thread-count="2" >
Code :
TestParallelForMethodsExecution.java
public class TestParallelForMethodsExecution {
@Test
public void visitCodoidPage() {
String baseUrl = "https://codoid.com/";
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
WebDriver driver = new ChromeDriver();
driver.get(baseUrl);
driver.manage().window().maximize();
WebDriverWait wait = new WebDriverWait(driver, 25);
String testTitle = "QA Testing Company - Software Testing Services";
boolean isVerified = wait.until(ExpectedConditions.titleContains(testTitle));
Assert.assertTrue(isVerified);
WebElement elmntAboutUsTab = driver.findElement(By.xpath("//ul[@id='top-menu']/li/a[text()='About Us']"));
elmntAboutUsTab.click();
driver.close();
}
@Test
public void visitAmazonPage() {
String baseUrl = "https://www.amazon.in/";
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
WebDriver driver = new ChromeDriver();
driver.get(baseUrl);
driver.manage().window().maximize();
WebDriverWait wait = new WebDriverWait(driver, 25);
String testTitle = "Online Shopping site in India";
boolean isVerified;
isVerified = wait.until(ExpectedConditions.titleContains(testTitle));
Assert.assertTrue(isVerified);
driver.close();
}
}
TestNG.xml
<suite thread-count="2" name="Parallel-Test-Suite" parallel="methods">
<test name="To Run TestNG :: Parallel methods concept">
<classes>
<class name="scripts.TestParallelForMethodsExecution"/>
</classes>
</test>
</suite>
ii. parallel=”tests”:
But the problem is that the above type will not work if we have a lot of test methods that are dependent on each other like how we saw earlier with the email example. So this attribute can be used to overcome this issue by adding all the dependent tests to a suite file (Testing.xml) and executing it separately in a thread as each tag will be considered a test suite and it’ll be executed in a separate thread.
Syntax:
<suite name="Test-Suite" parallel="tests" thread-count="2">
Code
MultipleSession1.java
public class MultipleSession1 {
public static WebDriver driver = null;
public static WebDriverWait wait = null;
@Test
public void visitAmazonPage() {
String baseUrl = "https://www.amazon.in/";
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
driver = new ChromeDriver();
driver.get(baseUrl);
driver.manage().window().maximize();
wait = new WebDriverWait(driver, 25);
String testTitle = "Online Shopping site in India";
boolean isVerified;
isVerified = wait.until(ExpectedConditions.titleContains(testTitle));
Assert.assertTrue(isVerified);
}
@BeforeMethod
public void beforeMethod() {
System.out.println("\n Starting Test On Chrome Browser");
}
@AfterTest
public void terminateBrowser() {
driver.close();
}
}
MultipleSession2.java
public class MultipleSession2 {
public static WebDriver driver = null;
public static WebDriverWait wait = null;
@Test
public void visitCodoidAboutUsPage() {
String baseUrl = "https://codoid.com/";
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
driver = new ChromeDriver();
driver.get(baseUrl);
driver.manage().window().maximize();
wait = new WebDriverWait(driver, 25);
String testTitle = "QA Testing Company - Software Testing Services";
boolean isVerified = wait.until(ExpectedConditions.titleContains(testTitle));
Assert.assertTrue(isVerified);
WebElement elmntAboutUsTab = driver.findElement(By.xpath("//ul[@id='top-menu']/li/a[text()='About Us']"));
elmntAboutUsTab.click();
}
@BeforeMethod
public void beforeMethod() {
System.out.println("\n Starting Test On Chrome Browser");
}
@AfterTest
public void terminateBrowser() {
driver.close();
}
}
TestNG.xml
<suite thread-count="2" name="Parallel-Test-Suite" parallel="tests">
<test name="To Run TestNG :: Parallel Tests concept - 1">
<classes>
<class name="scripts.MultipleSession1"/>
</classes>
</test>
<test name="To Run TestNG :: Parallel Tests concept - 2">
<classes>
<class name="scripts.MultipleSession2"/>
</classes>
</test>
</suite>
iii. parallel=”classes”:
This type has similar usage scope as the previous one with one major difference. Using this attribute, we can execute tests under each class in an individual thread, and the same has been explained in the below example.
Syntax:
<suite thread-count=”2” name =”Parallel-Test-Suite” parallel=”classes”>
Code:
Test1.java
public class Test1 {
public static WebDriver driver = null;
public static WebDriverWait wait = null;
@Test
public void Test1() {
String baseUrl = "https://codoid.com/";
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
driver = new ChromeDriver();
driver.get(baseUrl);
driver.manage().window().maximize();
wait = new WebDriverWait(driver, 25);
}
@Test
public void Test2() {
String testTitle = "QA Testing Company - Software Testing Services";
boolean isVerified;
isVerified = wait.until(ExpectedConditions.titleContains(testTitle));
Assert.assertTrue(isVerified);
}
@Test
public void Test3() throws InterruptedException {
WebElement elmntAboutUsTab = driver.findElement(By.xpath("//ul[@id='top-menu']/li/a[text()='About Us']"));
elmntAboutUsTab.click();
}
@AfterTest
public void terminateBrowser() {
driver.close();
}
}
Test2.java
public class Test2 {
public static WebDriver driver = null;
public static WebDriverWait wait = null;
@Test(priority = 1)
public void launchAmazonURL() {
String baseUrl = "https://www.amazon.in/";
System.setProperty("webdriver.chrome.driver", "./resources/drivers/chromedriver.exe");
driver = new ChromeDriver();
driver.get(baseUrl);
driver.manage().window().maximize();
wait = new WebDriverWait(driver, 25);
}
@Test(priority = 2)
public void verifyAmazonTitle() {
String testTitle = "Online Shopping site in India";
boolean isVerified;
isVerified = wait.until(ExpectedConditions.titleContains(testTitle));
Assert.assertTrue(isVerified);
}
@Test(priority = 3)
public void navigatesToAboutUsPage() throws InterruptedException {
WebElement elmntAmazonPayTab = driver.findElement(By.xpath("//a[text()='Amazon Pay']"));
elmntAmazonPayTab.click();
}
@BeforeMethod
public void beforeMethod() {
System.out.println("\n Starting Test On Chrome Browser");
}
@AfterTest
public void terminateBrowser() {
driver.close();
}
}
TestNG.xml
<suite thread-count="2" name="Parallel-Test-Suite" parallel="classes">
<test name="Using Classes attributes for parallel execution.">
<classes>
<class name="scripts.Test1"/>
<class name="scripts.Test2"/>
</classes>
</test>
</suite>
In the above 3 points, it can be seen that we have defined the keywords for parallel (classes, tests, and methods) attributes on the Testing.xml file. Now, we’re going to explain the sample scripts for classes and methods.
Conclusion:
As promised at the beginning of this TestNG tutorial, we have explored all the plus points of TestNG. So we hope this information would be useful and that you have enjoyed reading this blog. As one of the leading automation testing companies, we have always found TestNG beneficial in crucial circumstances, and hope it will come in handy for you as well.
by admin | Apr 13, 2021 | Selenium Testing, Fixed, Blog, Latest Post |
In every interview, there is that one common question that an automation tester would face, and that question is, ‘What is the use of Selenium WebDriver Event Listener?’. So in this blog article, we are going to precisely answer that question for you. In addition to that, once you have read this article, you will be in a position to use Selenium WebDriver Event Listener effectively to its full potential.
Selenium WebDriver is a Web Browser automation framework, and everyone is aware of that. Let’s say you want to capture a screenshot after a test case execution, you can write Selenium’s screen capturing snippet inside the testing framework’s ‘afterEach’ hook method. For example, if you want to capture a screenshot before/after every element click. You would have to write a screen capture snippet right after every click action which is not only a cumbersome task to do, but it is also a waste of valuable time. But you can make this process so much easier than this by making use of Selenium Event Listener. By using Selenium Event Listener, you can write the screenshot snippet inside the ‘beforeClickOn’ or ‘afterClickOn’ method.
Selenium has an interface called the ‘WebDriverEventListener’, which has 27 methods. All these methods are event listeners for Selenium WebDriver’s important actions. Let’s not leave any stone unturned and explore them one by one.
Implement WebDriver Event Listener Methods
First and foremost, you would have to create a class that implements the listener methods. Once that is done, you can create a concrete class for the WebDriverEventListener interface as shown below.
import org.openqa.selenium.support.events.WebDriverEventListener;
public class MyListener implements WebDriverEventListener {
}
As soon as you have created the class, your IDE will ask you to implement the listener methods. Once you accept the implementation, your class will have all the 27 methods.
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.events.WebDriverEventListener;
public class MyListener implements WebDriverEventListener {
@Override
public void beforeAlertAccept(WebDriver driver) {
}
@Override
public void afterAlertAccept(WebDriver driver) {
}
@Override
public void afterAlertDismiss(WebDriver driver) {
}
@Override
public void beforeAlertDismiss(WebDriver driver) {
}
@Override
public void beforeNavigateTo(String url, WebDriver driver) {
}
@Override
public void afterNavigateTo(String url, WebDriver driver) {
}
@Override
public void beforeNavigateBack(WebDriver driver) {
}
@Override
public void afterNavigateBack(WebDriver driver) {
}
@Override
public void beforeNavigateForward(WebDriver driver) {
}
@Override
public void afterNavigateForward(WebDriver driver) {
}
@Override
public void beforeNavigateRefresh(WebDriver driver) {
}
@Override
public void afterNavigateRefresh(WebDriver driver) {
}
@Override
public void beforeFindBy(By by, WebElement element, WebDriver driver) {
}
@Override
public void afterFindBy(By by, WebElement element, WebDriver driver) {
}
@Override
public void beforeClickOn(WebElement element, WebDriver driver) {
}
@Override
public void afterClickOn(WebElement element, WebDriver driver) {
}
@Override
public void beforeChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend) {
}
@Override
public void afterChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend) {
}
@Override
public void beforeScript(String script, WebDriver driver) {
}
@Override
public void afterScript(String script, WebDriver driver) {
}
@Override
public void beforeSwitchToWindow(String windowName, WebDriver driver) {
}
@Override
public void afterSwitchToWindow(String windowName, WebDriver driver) {
}
@Override
public void onException(Throwable throwable, WebDriver driver) {
}
@Override
public <X> void beforeGetScreenshotAs(OutputType<X> target) {
}
@Override
public <X> void afterGetScreenshotAs(OutputType<X> target, X screenshot) {
}
@Override
public void beforeGetText(WebElement element, WebDriver driver) {
}
@Override
public void afterGetText(WebElement element, WebDriver driver, String text) {
}
}
Attaching EventListener with WebDriver
Now that the event listener class has been created, your next task would be to attach the web driver instance with the event listener, and that can be easily done by following the method shown below.
WebDriver driver = new ChromeDriver();
driver.get(“http”://codoid.com);
EventFiringWebDriver eventHandler = new EventFiringWebDriver(driver);
MyListener listener = new MyListener();
eventHandler.register(listener);
The real value of the WebDriver Event Listener comes from your idea and purpose. If you don’t have a purpose to use it, then implementing Event Listener is simply a waste of time. So, make sure to put in some time and thought before you go straight ahead and start things up. In the upcoming sections, as a test automation company, we have shared how we have effectively used Selenium WebDriver Event Listener for our automation testing projects. Let’s take a look at it beginning from ‘onException’.
onException
When you are in a situation that requires you to run a test suite multiple times, there are chances of getting some failures because of the script or application issues. Selenium has 33 common exceptions. If you manage to capture all these exceptions which are thrown during automated test suite execution, it will be extremely useful for auditing purpose. Let’s say you want to know which Selenium exception was triggered the most often in the past three weeks. When you have the exception history & metrics in hand, you can understand whether the automated test suite is stable enough or if it needs any minor tweaks.
Capturing Selenium Exceptions in the ‘onException’ method is pretty easy. But the question here is, ‘How can you store the exceptions for future reference?’. Well, the solution is easy too, as you can use Sentry to store the exceptions. If you are fairly new to Sentry or unaware of how to configure it in your framework, don’t be worried, we’ve got you covered. All you have to do is follow the steps that are listed below to easily configure Sentry in your test automation framework.
Step 1
Add the Sentry maven dependency in POM.xml
<dependency>
<groupId>io.sentry</groupId>
<artifactId>sentry</artifactId>
<version>4.3.0</version>
</dependency>
Step 2
Sign-up in Sentry and create a project.
Step 3
Once the Sentry project is created, you will get the below code which needs to be integrated with your test suite.
Sentry.init(options -> {
options.setDsn("https://2323.ingest.sentry.io/2323);
});
Note: Each project has its own DSN. So make sure to copy the above snippet from your project and not from here.
Step 4
Create a constructer in the Listener class and add Sentry config inside the constructer.
public class MyListener implements WebDriverEventListener {
public MyListener(){
Sentry.init(options -> {
options.setDsn("https://2323.ingest.sentry.io/2323);
});
}
}
Step 5
Now ingest the exceptions in the Sentry from the ‘onException’ method.
@Override
public void onException(Throwable throwable, WebDriver driver) {
Sentry.captureException(throwable);
}
afterFindBy
Nowadays, setting up a test automation framework is fairly simple. If you are using JVM-Cucumber & Selenium WebDriver, then the framework setup is pretty much straightforward in all aspects. You need to write Scenarios in the Gherkin format, implement a step definition for each Gherkin step using Page Object, and finally integrate the other required components.
In order to produce a robust test automation suite, you would need the following:
- A simple and concrete framework
- A Stable Environment
- A Skilled Team
- A team that follows good Object Locating Techniques
The first three requirements are default elements that every test automation suite must-have. When you have a truly skilled Automation Testing Team, then it is pretty much a given fact that they will follow good object locating techniques. However, you just can’t have the same team members for a longer period. So it is vital to ensure the scripting standards and object locating strategies even with the new team members to maintain the robustness of your test automation suite.
As a QA company, we use peer review and pair scripting sessions to ensure the test automation’s scripting quality and its robustness. However, it is a tedious task to review locators for each object. What we do in the afterFindBy method is, use regular expression and search sub-string logics to verify if the XPaths & CSS Selectors have met the standards that have been set.
beforeClickOn
The ‘beforeClickOn’ method comes in handy when you need to take screenshots of every click action for a workflow. Let’s say someone from your team wants to know what and all buttons/links/objects were clicked in an E2E test. Inside the ‘beforeClickOn’ method, you can access the driver instance and save the screenshot in a PDF file.
When you implement the ‘beforeClickOn’ method, make sure to create a config variable to decide whether you would need a screenshot before every click action or not. Another useful aspect is that, instead of saving the page screenshots before clicking, you can store WebElement screenshots and compare them with the excepted images. When you perform visual testing, you can catch if the CSS Styles are not applied for the Web Elements which is also a major advantage.
Conclusion
We hope you have enjoyed reading this blog article and that it will positively impact your efficiency. Now it is time for you to try and implement Selenium WebDriver Event Listener for any of these ideas in your project and see the results for yourself. If you would like to recommend any other ideas that will help improve the existing methods, please feel free to head over to the comments section share your valuable thoughts. Test Automation Services is one of the core services of Codoid. Our team is always ready to explore new implementations using Selenium & Appium. Subscribe to our blog so that you never miss out on our highly useful automation testing blog articles that will help you be at the top of your game.
by admin | Apr 6, 2021 | Automation Testing, Fixed, Blog, Latest Post |
Automation testing using JavaScript has been gaining popularity in recent days making a blog about the best JavaScript Testing Frameworks available the need of the hour. A conversation between business analysts, developers, and testers about a feature will become specifications. After that, the developers & testers convert the specs into automated acceptance tests. Automated tests help the team to drive the feature development as passing acceptance tests prove the fact that the agreed feature has been developed as expected.
To convert specifications into automated acceptance tests, devs & QAs should use the same programming language. Let’s say your team is using JavaScript for development and Java for automation testing. In this case, you won’t be able to enable effective collaboration between the developers & testers which is a big concern. Analysts & developers can capture acceptance criteria effectively. However, testers are good at adding edge cases making them invaluable as well. That is why everyone’s involvement right from the beginning is vital with common tools, frameworks, and language.
In this blog article, we have listed the best JavaScript Testing Frameworks which are widely used for writing unit tests and acceptance tests.
Jasmine
When developers focus more on components than features, they don’t add value to the business. Writing tests in plain English helps your team focus on the business goals and Jasmine is one of the best testing frameworks to make it possible. Using Jasmine you can write meaningful tests which can be understood by everyone in the team and help the developers to write higher quality code more efficiently.
Jasmine has support for Node.JS, RUBY, and Python. If you want to run the tests on a Web Browser instead of running them in interpreter/programming engine, then you can go for Jasmine Standalone. Now let’s find out how to use Jasmine in Node.JS beginning right from its installation.
Installation:
To install Jasmine, run the below npm command.
npm install jasmine —save-dev
Initialization
To set up Jasmine in a Node.JS project, you need spec files and jasmine.json (Configuration file). You can add these files manually. However, we have an npx command to initialize Jasmine in your project and it has been listed below
After running the above command, you can find the ‘spec’ folder and ‘jasmine.json’ file under the spec->support folder.
Add Jasmine in package.json
Now, you need to inform your node project that you are using Jasmine for testing. Open package.json and update the ‘test’ value as ‘jasmine’ as shown below.
{
"name": "jasmine-sample",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "jasmine"
},
"author": "",
"license": "ISC",
"devDependencies": {
"jasmine": "^3.7.0"
}
}
Describe
In order to group related test cases like how we group scenarios in a feature file in Cucumber, you need to create a JavaScript file and write a ‘describe’ function as shown below.
describe("User Management", ()=>{
})
In the above function, it is a placeholder to add ‘User Management’ related test cases.
Specs
Specs are your test cases. You need to write specs inside the ‘describe’ function as shown below.
describe("User Management", ()=>{
it("should signup",()=>{
})
it("should login", ()=>{
})
})
As we mentioned earlier, everyone in the team should understand what is the purpose of each test. When naming a test case for unit & acceptance tests, you need to describe what you are expecting. However, it is a cumbersome task for a developer to focus on names. If there are a rule and a standard which come from the testing framework, then the team members will be able to stick to the business goals and focus on achieving them instead of concentrating only on the code components.
That is why the Jasmine framework has the ‘it’ function and the first argument starts with ‘should’. When a test case says ‘It should do something’, the developer will focus on that something throughout the development which is exactly what we want.
How is a spec pass or fail determined? You can have multiple assertion lines inside a spec and even if one of those assertions fails, the spec will be marked as ‘Fail’.
Assertions
Jasmine has an in-built assertion function which is called ‘expect’. Expect function has one argument which takes the actual value. You can also chain the assertion using Matcher functions.
expect(“my string”).toMatch(/string$/) – Expect the actual value to match a regular expression.
expect(bigObject).toEqual( “foo”: ‘bar’, ‘baz’ ) – Expect the actual value to be equal to the expected value using deep equality comparison.
expect(thing).toBe(realThing) – Expect the actual value to be === to the expected value.
Configurations
Jasmine has a total of five configurations in the jasmine.json file. Let’s take a look at the purpose of each of these configurations one by one.
“specdir” – A directory path where you have the specs in the current project directory.
“specfiles” – You can include & exclude spec file paths with regular expression.
“helpers” – Before the test execution commences, you may need some supporting files that should be executed. The helpers config is the placeholder to mention the supporting JS files.
“stopSpecOnExpectationFailure” – This is a boolean config. If the value is true, then the spec execution will be stopped when the first assertion is failed.
“random” – Run the specs in random order.
Advantages of Jasmine
- You can customize the Jasmine report.
- It has a very strong community that supports the users.
- You can even create your own Matchers.
- It is extremely simple and easy to use making it the choice of many developers and testers mainly for its simplicity.
Jest
Jest is also a popular JavaScript Testing framework that works with Node.JS, React, Angular, Vue, Babel, TypeScript, and more. Jest was developed by Facebook and so it runs thousands of tests for Facebook on a daily basis. Apart from Facebook, there are many other prominent companies that also use Jest. So let’s see what makes Jest one of the best JavaScript Testing Frameworks and how you can implement it in your project. Let’s begin with its installation process.
Installation
You can easily install Jest by making use of the below code,
npm install --save-dev jest
Add Jasmine in package.json
Update scripts>test node as ‘jest’ in Package.json as shown below.
{
"name": "jest-sample",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "jest"
},
"keywords": [],
"author": "",
"license": "ISC",
"devDependencies": {
"jest": "^26.6.3"
}
}
Configuration
No configuration is required to write or run Jest tests. However, every testing framework has its own configuration file. To create a config file, you can run the below command.
Once you run the above command, Jest will ask you a few questions to create the config file.
Migrating from Jasmine to Jest
If you are planning to migrate from Jasmine to Jest, then we’ve got some good news for you as Jest is compatible with Jasmine tests. This makes the migration far less complicated. However, if you want to do a code-level migration, you can use third-party jest-codemods for the best results.
Assertions
In order to write assertions elegantly in a test, you would definitely need sophisticated Matchers. Jest has a lot of compressive matchers that you could use. However, we have listed some of the commonly used Matchers below.
test('two plus two is four', () => {
expect(2 + 2).toBe(4);
});
test('object assignment', () => {
const data = {one: 1};
data['two'] = 2;
expect(data).toEqual({one: 1, two: 2});
});
test('null', () => {
const n = null;
expect(n).toBeNull();
expect(n).toBeDefined();
expect(n).not.toBeUndefined();
expect(n).not.toBeTruthy();
expect(n).toBeFalsy();
});
Snapshot Testing
Your Acceptance Tests test the application under test by performing actions on the UI. However, it never validates whether the UI is rendered as same as before and if the CSS styles are applied correctly or not. Jest has a feature to address this issue (i.e. Visual Regression Testing). Using Jest, you can capture snapshots and compare them with the expected snapshot thereby creating a huge advantage if that is your primary need.
Advantages
If you want to run your tests in parallel, then Jest is your go-to testing framework. Jest has numerous assertion functions. In terms of ease of adoption, simplicity, support, and documentation, Jest is hands down the clear winner.
Mocha
Mocha is a JavaScript Testing framework only for Nod.JS. Mocha doesn’t have an in-built assertion library. However, it allows you to use the following libraries such as should.js, chai, expect.js, better-assert, and unexpected for assertions. You can execute tests in two modes (Serial & Parallel).
Conclusion
Jest and Jasmine are the best JavaScript Testing frameworks. However, most of the engineers are comfortable with Jasmine over Jest. As an automation testing company, we use Jasmine for Protractor automation testing. Jasmine is the default testing framework for Protractor. Our suggestion is not final and it shouldn’t influence your framework decision.
Jest has many sophisticated features such as Configuring Visual Testing (i.e. Snapshot Testing) which is not as easy to do in Jasmine. However, in Jest, it is pretty straightforward. Apart from that, test creation and assertions are similar in both these frameworks. If you feel Jest is suitable for your project, please go ahead.
