Selenium Headless Tests on Browsers: A Step-by-Step Guide

When you execute your tests in headless mode, it means your tests are being executed in the background, without launching the UI. These tests are more efficient to run because the UI does not need to be rendered. When automated tests are executed, headless test execution can improve the efficiency of the tests too. 

In this blog, we will see how we can use Selenium to execute your tests on chrome in headless mode.

What are the Advantages Of Executing your Selenium Tests in  Headless Mode?

Running Selenium tests in headless mode has several benefits:

Faster execution: Executing tests on a browser in headless mode eliminates the need to render for a browser GUI, which can slow test execution.

Better resource use: Executing a browser in headless mode uses less memory and CPU than running tests with a browser GUI.

Greater flexibility: When tests are executed in headless mode, they can be easily executed on even remote and virtual machines. 

More efficient testing: Faster execution + Better resource use = More efficiency in test execution

What are the Disadvantages of Executing Selenium Tests in Headless Mode?

While executing your tests in selenium headless mode has many benefits, there are also some limitations to be aware of:

Limited browser support: Some browsers do not support headless mode of execution, so this might not be an option for specific projects.

Limited debugging capabilities: A browser in headless mode does not have a GUI, so it can be more challenging to debug test failures and other issues.

Limited visualization: Some testing scenarios, such as visual regression testing, may not be possible. With a GUI, it can be easier to visualize the results of tests and understand how the application behaves.

Limited support for browser plugins: A browser in headless mode does not support plugins, limiting the functionality of the tests you run.

Executing Selenium Tests in Headless Mode With HTMLUnitDriver

HTMLUnitDriver is an implementation of WebDriver that drives HtmlUnit, which is a headless (GUI-less) browser simulator. Thus, when you want to execute your tests in headless mode, you can use HTMLUnitDriver in place of Selenium WebDriver.

How to use HtmlUnitDriver for headless test execution with Selenium?

To use the HtmlUnitDriver with Selenium, you must have the Selenium WebDriver and HtmlUnitDriver libraries installed in your project. 

Here is an example of how to set up and run a headless test using the HtmlUnitDriver in a Java environment:

1. Import the necessary libraries:

2. Create an instance of the HtmlUnitDriver class:

3. Navigate to the desired website using the driver’s get() method:

4. Perform any desired actions on the website, such as clicking buttons or filling out forms, using Selenium WebDriver’s various methods for interacting with the page.

5. Run assertions to check the page’s expected state

6. Close the browser using the driver’s quit() method:

Using the HtmlUnitDriver, Selenium will run the tests without opening an actual browser window, making it a headless browser. The HtmlUnitDriver supports JavaScript and can run on various platforms, making it an excellent choice for selenium headless test execution.

Enabling JavaScript support in HtmlUnitWebDriver

The HtmlUnitDriver, by default, has JavaScript support enabled. However, if you want to confirm that JavaScript support is enabled or if you need to enable it, you can utilize the following technique.:

1. Create an instance of the HtmlUnitDriver class and set the JavaScriptEnabled property to true:

Or

2. Once you have set the JavaScriptEnabled property to true, you can use the driver to navigate a website and interact with it like any other WebDriver.

Example showing usage of HTMLUnitDriver to run Selenium test cases in Headless mode:

Here is an example of using the HtmlUnitDriver to run Selenium test cases in headless mode:

In this example, we are using JUnit as our test runner and creating a new instance of the HtmlUnitDriver. 

Then we navigate to Google’s homepage, enter a search query, submit the form, and wait for the page to load. Then we assert that the page’s title starts with “Selenium WebDriver.”

Using HtmlUnitDriver, Selenium will run the tests without opening an actual browser window, making it a headless browser and allowing you to run your test cases in headless mode. 

How to run tests on different browser versions using HtmlUnitDriver?

HtmlUnitDriver allows you to run tests on different browser versions by specifying the browser version when creating an instance of the driver. 

Here’s an example of how to run tests on different browser versions using HtmlUnitDriver:

In this example, we are creating an instance of HtmlUnitDriver and passing in the browser version we want to use (Firefox, Chrome, Edge) as a parameter to the constructor. This will allow you to run your tests on different browser versions.

Running Selenium Tests for Chrome Browser in Headless Mode

To run Selenium tests on chrome in headless mode, you must have the Selenium WebDriver, ChromeDriver, and Chrome browser installed in your system. 

Here is an example of how to set up and run a Selenium test on Chrome in headless mode in JAVA:

1. Download the ChromeDriver executable from the official website and ensure it’s in your system’s PATH.

2. Import the necessary libraries:

3. Create an instance of the ChromeOptions class and add the –headless option to the arguments list:

4. Create an instance of the ChromeDriver class and pass the options to it:

5. Navigate to the desired website using the driver’s get() method:

6. Perform any desired actions on the website, such as clicking buttons or filling out forms, using Selenium WebDriver’s various methods for interacting with the page.

7. Run assertions to check the page’s expected state

8. Close the browser using the driver’s quit() method:

This way, the Selenium tests will run without opening an actual browser window. This can be useful for running tests on a server or in an automated pipeline where a GUI is unavailable. 

Running Selenium Tests for Firefox Browser in Headless Mode

To run Selenium tests on a Firefox browser in headless mode, you must have the Selenium WebDriver, FirefoxDriver, and the Firefox browser installed in your system. 

Here is an example of how to set up and run a headless test using the Firefox browser in a Java environment:

1. Download the FirefoxDriver executable from the official website and add it to your system’s PATH:

2. Import the necessary libraries:

3. Add the -headless option to the arguments list when creating a new instance of the FirefoxOptions class:

4. Generate a FirefoxDriver class instance and give it the options:

5. Use the driver’s get() method to find the desired website:

6. Use the different methods Selenium WebDriver provides for interacting with the page to carry out any desired actions on the website, such as clicking buttons or completing forms.

7. Run assertions to verify the expected state of the page.

8. Use the driver’s quit() method to close the browser:

Selenium headless mode allows running tests on the Firefox browser without needing a visible browser window. This can be beneficial when tests need to be executed on a server or in an automated pipeline where a graphical user interface is not present.

Running Selenium Tests for Edge Browser in Headless Mode

Running Selenium tests for Edge browser in headless mode is similar to running these tests for Chrome or Firefox.

You will need to have the Selenium WebDriver, EdgeDriver, and the Edge browser installed on your system. Here is an example of how to set up and run a test using the Edge browser in a Java environment:

1. Make sure the EdgeDriver executable is in your system’s PATH by downloading it from the official website.

2. Import the necessary libraries:

3. Make a new instance of the EdgeOptions class, and add the –headless argument:

4. Set up an instance of the EdgeDriver class and give it the options:

5. Using the get() method of the driver, navigate to the desired website:

6. Using Selenium WebDriver, perform any desired actions on the website, such as clicking buttons or filling out forms, by utilizing various methods for interacting with the page.

7. Execute assertions to verify the expected state of the page.

8. Close the browser with the quit() method of the driver:

Running Selenium Tests for Edge Browser in Headless Mode, this feature is helpful in scenarios where tests need to be run on a server or within an automated pipeline where a graphical user interface is unavailable.

Summary

In this blog we discussed how to execute your selenium tests in a browser in headless mode. 

Though Selenium is a very useful tool for cross-browser test execution, in default or headless mode, it does require some programming expertise. That also means it can be time-consuming. 

Testsigma is a no-code test automation tool that is built to automate your cross-browser tests. In addition, you can also automate your tests for mobile, APIs and desktop too. With Testsigma, you create test cases in simple English and the barrier of learning to code is completely removed. Besides, Testsigma is open source too.

Try out Testsigma open source for your test automation needs here.

Frequently Asked Questions:

Is Selenium headless faster?

Running Selenium tests in headless mode can be faster than running them in a non-headless mode, as it eliminates the overhead of running an actual browser window. In headless mode, the browser’s rendering engine is used to load and interact with the web pages, but it doesn’t have to render the pages to a visible window, which can save time.

Why use headless Selenium?

Headless Selenium is a way to run Selenium tests without a visible browser window. It can be faster, allows running tests on a server or headless environment, is cost-effective, easier to set up, and compatible with widely used browsers. 

What is a headless API?

A headless API is an API (Application Programming Interface) that allows developers to access the functionality of a system or application through code without the need for a graphical user interface (GUI).