Selenium WebDriver is an open source library that allows controlling web browsers (e.g., Chrome, Firefox, Edge, etc.) programmatically using different languages (such as Java, JavaScript, Python, Ruby, or C#). Internally, Selenium WebDriver uses the native support implemented by each browser to carry out the automation process. For this reason, we need to place a component called driver (e.g., chromedriver, geckodriver, msedgedriver, etc.) between the script using the Selenium WebDriver API and the browser. 

Historically, the Selenium project did not cover the automated management (understood as the process of download, setup, and maintenance) of drivers. For this reason, different projects in the Selenium ecosystem emerged to do this task (such as WebDriverManager in Java or webdriver-manager in Python, among others). As of Selenium 4.6.0, automated driver management is shipped in Selenium WebDriver out of the box. This way, the driver management is done automatically and transparently for all Selenium WebDriver binding languages. This process is done through a new official tool of the Selenium portfolio called Selenium Manager.

Selenium Manager is a CLI tool developed in Rust. It provides a robust mechanism to detect the version of the local browser to be controlled with Selenium WebDriver, download the proper driver, and make it available for Selenium WebDriver. Moreover, Selenium Manager has another relevant feature in its roadmap: the automatic management (i.e., download and installation) of browsers (such as Chrome, Firefox, or Edge).

Selenium Manager has been built with the lessons learned from the development of WebDriverManager (first released in 2015). This way, the history of Selenium Manager is the history of how an independent third-party project has become part of the Selenium code development.

Selenium WebDriver is a library that allows controlling web browsers (e.g., Chrome, Firefox, Edge, etc.) programmatically using different languages (such as Java, JavaScript, Python, Ruby, or C#). Internally, Selenium WebDriver uses the native support implemented by each browser to carry out the automation process. For this reason, we need to place a component called driver (e.g., chromedriver, geckodriver, msedgedriver, etc.) between the script using the Selenium WebDriver API and the browser. WebDriverManager is an open-source Java library that carries out the management (i.e., download, setup, and maintenance) of the drivers required by Selenium WebDriver in a fully automated manner. In addition, as of version 5, WebDriverManager provides other relevant features, such as discovering browsers installed in the local system and building WebDriver objects, and running browsers in Docker containers seamlessly. The last feature added to WebDriverManager is related to log gathering. As of version 5.2.0, WebDriverManager provides seamless integration with BrowserWatcher, an open-source browser extension that allows gathering the browser console programmatically (even for Firefox, which was not possible to date). 

Selenium has become the de-facto standard framework for end-to-end web testing nowadays. JUnit 5 is the latest version of this popular testing framework and implements a brand-new programming and extension model named Jupiter. This talk presents Selenium-Jupiter (https://bonigarcia.github.io/selenium-jupiter/), an open-source JUnit 5 extension aimed to provide seamless integration with Selenium. At first glance, it allows creating Selenium tests using local or remote browsers, reducing the required boilerplate thanks to the dependency injection mechanism supported in JUnit 5. Moreover, it will enable us to use different types of web browsers and Android devices in Docker containers out of the box. All in all, Selenium-Jupiter can be used to carry out different types of tests for web and mobile applications, including functional, compatibility (using test templates to define different devices or browsers -types and versions-) or performance tests.

One of the main benefits of end-to-end tests with Selenium is the simulation of real user scenarios in an automated fashion. Nevertheless, end-to-end tests are often criticized because these kinds of tests do not isolate failures, and therefore troubleshooting failures can be difficult and costly for testers. This talk pretenses different techniques aimed to solve this problem. The objective is to provide useful assets to find the root cause of a failure in a Selenium test. The first one is screenshotting. Once a failure is detected, the state of the browser just before the failure happens can provide the clue to determine the nature of the problem. If the screenshot is not enough, the next step is to watch the browser during the test to observe the evolution of the web under test. This process is straightforward when running a test with the local browser, but it can be tricky in the usual case of running a test in a headless environment, such as Jenkins or Travis to name a few. The solution proposed is twofold. On the one hand, a Selenium session can be recorded using Virtual Frame Buffer (xvfb) and FFmpeg. On the other hand, we can use web browsers and mobile devices in Docker containers, in which the GUI session can be easily recorded using VNC and FFmpeg. The last mechanism proposed is the access to browser logs to debug the JavaScript traces of our applications. Unfortunately, the Selenium API only allows us to do it when Chrome is used as a browser. The solution proposed is to use monkey patching in the console object at JavaScript level in a cross-platform browser extension which is used to instrumentalize the browser (e.g., Firefox, Opera) controlled with Selenium WebDriver. All these mechanisms have been implemented in Selenium-Jupiter, a JUnit 5 extension for Selenium providing seamless integration with Docker. To ease the access to such information, Selenium-Jupiter provides seamless integration with Jenkins and Slack, publishing the resulting files (PNG screenshots, MP4 recordings, and TXT logs) in the Jenkins GUI or Slack channel when a test fails.

Docker is a container technology that has become pervasive in current software architecture and infrastructure nowadays. Kubernetes is a container orchestration platform, allowing large numbers of containers to work together. This presentation presents how Docker and Kubernetes can be used to create advance Selenium tests. The use of containers allows using different types of web browsers and Android devices in Docker containers out of the box, allowing to create functional or compatibility (using different devices and/or browsers types and versions) in an effortless manner. The use of a Kubernetes cluster allows to scale up the approach, allowing to a use huge number of browsers to develop performance or load tests with Selenium. All these mechanisms have been implemented in Selenium-Jupiter, a JUnit 5 extension for Selenium which provides seamless integration with Docker and Kubernetes.

Moreover, Selenium-Jupiter can be executed as a Server which speaks the JSON wire protocol/W3C WebDriver, becoming into a Selenium Server. In this case, Selenium-Jupiter acts as a scalable hub (using the Selenium Grid jargon), providing browsers for any kind of Selenium script (Java, JavaScript, Python, etc.) using Docker and Kubernetes internally to allocate the requested browsers types (Chrome, Firefox, Opera, Explorer, Edge, and Android devices) and versions (stable, beta, dev).

JUnit is the most popular test frameworks for Java and one of the most influential in software engineering in general. On September 2017 JUnit 5 was released, providing a brand-new programming and extension model for testers. This talk presents Selenium-Jupiter (https://bonigarcia.github.io/selenium-jupiter/), an open source extension for JUnit 5 which provides a rich toolbox aimed to simplify the testing process of web and mobile applications.

At a first glance, Selenium-Jupiter allows to test web applications using local browsers with Selenium WebDriver in a comprehensive way. Next, Selenium-Jupiter provides seamless integration with Selenium Grid and Appium, allowing to test web and mobile applications using remote browsers and mobile devices very easily.

As advanced feature, Selenium-Jupiter manages Docker containers running web browsers (Chrome, Firefox, and Opera) and Android devices, making them available for JUnit 5 tests in a transparent way for developers. This capability allows to create a rich variety of tests, such as compatibility (i.e. use the same test logic with different browsers and/or platform) or performance (i.e. use a big number of browsers/mobile devices against the same system under test). Furthermore, Docker containers can be monitored using VNC remote access, and Docker sessions can be recorded, providing advance mechanisms for debugging.

Besides all this, Selenium-Jupiter delivers more features, such as test templates (i.e. define the number and types of browsers/mobile devices to be used in the same test, both programmatically or using JSON notation), integration with Jenkins (allowing to publish screenshots or recording in the Jenkins interface), integration with cloud providers such as SauceLabs/BrowserStack/Genymotion, command-line interface (CLI), and even can be used as a server (i.e. acting as a Selenium/Appium server).