Many newcomers to web automation often ask, ‘What is Selenium?’ to understand how it can be used for browser-based testing. QA engineers may automate web application testing with Selenium, a well-known open-source testing technology. Its connectivity with multiple platforms and programming languages contributes to its flexibility in web automation.
An Overview of Selenium’s Project Components
WebDriver
For those starting with test automation for desktop or mobile websites, WebDriver APIs are essential. WebDriver employs browser automation APIs provided by browser vendors to control browsers and execute tests, simulating real user interactions. Since WebDriver operates independently of the application code, it is non-intrusive, ensuring that you test the same application version that goes live.
IDE (Integrated Development Environment )
This user-friendly extension for Chrome and Firefox is an efficient tool for test case development. This not only saves time but also helps in learning the syntax of Selenium scripts.
Grid
Selenium Grid enables the execution of test cases on multiple machines across various platforms. Test case execution is controlled locally, but when triggered, the tests run on remote machines. After developing WebDriver tests, there may be a need to test across multiple browsers and operating systems, which is where Selenium Grid becomes essential.
Evolution of Selenium
Selenium 1: Known for its JavaScript-based browser automation, supporting multiple browsers.
Selenium 2: Merged Selenium RC with WebDriver, enhancing performance and reliability.
Selenium 3: Achieved W3C standard status, making it a top choice for web and mobile application testing.
New Features in Selenium 4
Enhanced Selenium Grid:
- Docker Support: With Selenium Grid’s support for Docker, developers may now use containers rather of configuring bulky virtual machines.This facilitates easier scaling and deployment.
- Redesigned Architecture: The Grid can now be deployed in Standalone mode, Hub and Node mode, or Fully distributed mode. It supports IPv6 addresses and HTTPS communication, and configuration files can be written in the human-readable TOML format.
- User-Friendly GUI: The new Selenium Grid features an enhanced GUI, making it easier to manage and use, improving the overall DevOps process by integrating seamlessly with tools like Azure and AWS.
Upgraded Selenium IDE:
- Enhanced Features: The new IDE includes improved GUI, a SIDE tool for running .side projects on Node.js, better control flow mechanisms, and an advanced element locator strategy. Test cases recorded with Selenium IDE can be exported in various language bindings such as Java, C#, Python, .NET, and JavaScript.
Improved Documentation:
- The documentation for Selenium 4 has been significantly revamped with a user-friendly UI, making it easier to find relevant information. This extensive documentation covers all tools and APIs under the Selenium umbrella, helping beginners and experienced testers alike.
Support for Chrome Debugging Protocol:
- Selenium 4 includes native support for the Chrome DevTools Protocol, allowing QA engineers to use Chrome development properties like Fetch, Network, and Performance. This helps in simulating poor network conditions, performing geolocation testing, and resolving critical bugs more efficiently.
Better Window/Tab Management:
- A new API, newWindow, has been introduced in Selenium 4. It allows users to open and switch to a new window or tab without creating a new WebDriver object, simplifying tasks that require multiple browser windows or tabs.
W3C WebDriver Protocol:
- Selenium 4 WebDriver adheres to the W3C standard, eliminating the need for encoding/decoding API requests, which was required in Selenium 3. This ensures more stable cross-browser tests.
Selenium Manager Enhancements:
- Features a new interface, real-time monitoring, and advanced query capabilities, improving control over automated tests.
Advanced features of Selenium Grid
Selenium Grid
Selenium Grid helps in scaling and distributing tests by running them across different combinations of browsers and operating systems.
Observability:
Observability in systems relies on three main components: traces, metrics, and logs. With Selenium Grid 4 being fully distributed, enhanced observability simplifies understanding and debugging its internal workings.
Distributed Tracing:
Tracing monitors the lifecycle of these requests as each service processes them, which is particularly useful for debugging errors. Key concepts in tracing include:
- Trace: Represents a request’s whole path across several services, making it easier to troubleshoot and keep an eye on the entire process. Each trace has a unique identifier.
- Span: Consists of timed operations contained in a trace, each having a distinct identity and attributes that offer comprehensive data. The granularity depends on the instrumentation.
- Span Attributes
Event Logging:
Logging is crucial for debugging applications, often in a human-readable format but structured for machine analysis. Structured logging involves consistently recording logs in a fixed format, typically including fields such as:
- Timestamp
- Logging level
- Logger class
- Log message with relevant operational details
Events and logs are closely related, with events encapsulating comprehensive information for a unit of work and logs being subsets of events. Both are essential for debugging.
Grid Observability Selenium server uses OpenTelemetry for tracing. Each request to the server is traced from start to end, with traces comprising multiple spans.
- Normal event: Records all information about a unit of work and marks its successful completion.
- Error event: Records all information up to the point of error, including error details, marking an exception.
Running Selenium Server
There are several ways to operate Selenium server: Standalone, Hub and Node, fully distributed, and docker.
Visualizing Traces Tracing in Selenium server exports data via two main exporters:
- Console: Logs all traces and spans at FINE level, although default logs are at INFO level and above. The log-level flag can adjust this setting.
- Jaeger UI: OpenTelemetry instruments traces, while Jaeger collects and visualizes tracing telemetry data. Detailed instructions for using Jaeger UI are available with the command java -jar selenium-server-4.0.0-<selenium-version>.jar info tracing.
Leveraging Event Logs By default, tracing is enabled, and events are logged at FINE level, with error events at WARN level. Event logs include fields such as:
- Event time
- Trace ID
- Span ID
- Span Kind
- Event name
- Event attributes, formatted as JSON key-value pairs for detailed operational context
GraphQL Query:
Support GraphQL is an API query language and runtime for executing those queries with your existing data. It allows users to request exactly the data they need and nothing more.
Enums:
Enums define a set of possible values for a field. For instance, the Node object has a status field, which is an enum of type Status. It can have values like UP, DRAINING, or UNAVAILABLE.
Querying GraphQL:
The query should be formatted as JSON, with proper escaping of double quotes to avoid errors. GraphQL lets you retrieve only the specific data you need.
Grid Endpoints
Grid
Grid Status: Grid status provides the current state of the Grid, detailing each registered Node’s availability, sessions, and slots.
Delete Session: When a session is deleted, the WebDriver session ends, the driver is closed, and it is no longer visible on the map of current sessions. An error will be returned for any more requests made with the deleted driver instance or session ID.
Customizing a Node
How to Customize a Node
There are instances where we need to customize a Node to suit specific requirements. For example, you may want to perform additional setup before a session starts and cleanup after it finishes.
Steps to customize a Node:
- Create a Custom Class
- Add a Factory Method
- Implement Custom Logic: Include the logic for creating your custom class within this factory method.
- Integrate Custom Logic:
- Start the Node and pass the fully qualified class name of your custom class to the –node-implementation argument.
- If using Maven, prefer the maven-shade-plugin over the maven-assembly-plugin due to issues with merging multiple Service Provider Interface files (META-INF/services).
Custom Node as a Regular Jar
- Create a Sample Project: Use your preferred build tool (Maven or Gradle).
- Add Dependency.
- Add Customized Node: Implement your custom Node in the project.
- Build the Jar: Build the jar file of your project using your build tool.
- Start the Node.
Selenium Grid is a powerful component of Selenium that allows for setting up a local infrastructure for cross-browser testing. However, it has certain limitations, requiring careful selection of browser versions and platforms for testing.
To meet additional requirements beyond the initial setup, an extra node must be configured, which can be costly since it may involve purchasing new machines with specific operating systems, like macOS or certain Windows versions.
Cloud platforms like LambdaTest offer a solution by eliminating the need to maintain your own Selenium Grid setup, allowing you to focus on writing better automation code. LambdaTest also enables parallel execution of tests on a cloud-based Selenium Grid.
LambdaTest is an AI-driven test execution platform that facilitates testing websites and web applications across more than 3000 combinations of browsers, browser versions, and operating systems. It provides an online Selenium Grid for conducting automation testing in parallel, enhancing efficiency and scalability.
Selenium vs WebDriverIO: What Sets Them Apart?
WebdriverIO is an open-source framework used to automate web application testing. It was created in JavaScript with the intention of simplifying the process of automating browser interactions.
| WebDriverIO | Selenium |
| Built exclusively on the WebDriver protocol. | Includes Selenium IDE, WebDriver, Grid, and remote control. |
| Configuration is straightforward with configuration files. | Configuration varies by language and tools used. |
| Benefits from a well-documented and active support community. | Strong community support with extensive documentation. |
| Integrates well with testing frameworks like Mocha and Jasmine. | Compatible with various frameworks like JUnit, TestNG, etc. |
| Provides synchronous and asynchronous API operations. | Primarily offers synchronous API with some asynchronous support. |
| Includes native support for cross-browser testing. | Achieves cross-browser testing through WebDriver and Selenium Grid. |
| Integrates with cloud testing services like LambdaTest | Supports remote test execution via cloud services. |
Conclusion
Test efficiency is increased by Selenium Grid’s parallel test execution capability, and flexible and scalable test automation strategies are made possible by its connection with a variety of testing frameworks and tools.
Furthermore, Selenium’s open-source design, robust community support, and comprehensive documentation guarantee that testers and developers may always make use of and expand upon the tool’s capabilities. Selenium distinguishes itself as a flexible framework with features like cross-browser testing, remote execution, and smooth integration with cloud-based platforms like LambdaTest.
