Selenium Blog
Keep up to date with all Selenium news here!
This is the multi-page printable view of this section. Click here to print.
We’re very happy to announce the release of Selenium 4.27 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
Here is the latest iteration of the world’s most popular browser automation tool! This release brings significant updates across all supported languages, enhancing functionality, performance, and compatibility. From new features like FedCM command support in Python and improved BiDi handling in .NET to critical deprecations like CDP methods for Firefox.
getAttribute
in multiple languages as part of Selenium’s evolution.imghdr
with filetype
for better compatibility. (b1828bf108)setup.py
to pyproject.toml
. (673d2c78be)AppiumConnection
. (3a3c46b3c1)ClientConfig
. (e2023893c7)DetachedShadowRoot
exception handling. (7aabb8d1b4)uri
gem. (751bacb6bc)NoSuchElementException
. (4a0d05e50e)WebElement.getAttribute()
. (cd7303c437)GetAttribute
method for WebElements. (ac523a5d0a)Improved retry logic for session creation in distributed grids. (e4ab299ea4)
Improved session handling in Selenium Grid and reduced test flakiness. (b0464e1adf)
Enhanced server shutdown for faster termination. (62aa0e551e)
Implemented graceful handling of stale sessions and client timeouts. (b0464e1adf)
Improved detection of unsupported HTTP methods during request handling. (f56b3d07d9)
K8s: Allow multiple nodes of the same type in Helm configuration (#2475)
Special shout-out to everyone who helped the Selenium Team get this release out!
Swastik Baranwal
Michael Render
Andrew Nesbitt
Ed Manlove
Alex
Jose D. Gomez R.
Navin Chandra
Natalia Pozhidaeva
Sandeep Suryaprasad
Simon Benzer
HeeJun
Michael Render
Yevgeniy Shunevych
ian zhang
Jason Ren
Navin Chandra
Pallavi
Simon Benzer
Andrew Zipperer
Viet Nguyen Duc
Thanks as well to all the team members who contributed to this release:
Agustin Pequeno
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Viet Nguyen Duc
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy automating!
We’re very happy to announce the release of Selenium 4.26 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
Selenium 4.26.0 release introduces new features, key enhancements, and numerous bug fixes across different languages and components. This version focuses on improving compatibility, updating dependencies, enhancing internal logging, and providing broader WebDriver capabilities. Here are the most important updates:
Chrome DevTools support is now: v130, v129, and v128 (Firefox still uses v85 for all versions)
Selenium has at least 4.8M active users in the last 30 days. 800K more than 1 month ago!
Selenium Manager Enhancements: Added better handling for invalid browser versions and improved logging, helping to streamline browser management.
Expanded BiDi (Bidirectional WebDriver Protocol) Support for .NET: Continuing the work on BiDi for .NET, this release includes improved WebSocket communication, CDP DevTools integration, and expanded logging, advancing real-time and bidirectional interactions.
Grid UI Enhancements: New sorting options by Platform, Status, and ID, session timeout display, and WebSocket connection management for better performance and user experience.
CI/CD Pipeline Improvements: Numerous updates for CI workflows, such as artifact handling and new testing configurations, to boost stability and developer productivity.
Updated WebSocket communication and DevTools integration in the BiDi implementation, adding extensive internal logs to improve diagnostics (#14566, #14558).
Added support for the GetLog
command in the Remote WebDriver (#14549).
Enhanced configuration for PrintOptions
, allowing direct control over PageDimensions
and PageMargins
(#14593).
Deprecated several old constructors for cleaner exception handling and improved compatibility with Ahead-of-Time (AOT) compilation (#14574).
Increased property scope for improved compatibility with Appium (#14183).
Updated SpotBugs settings and fixed issues in ChromiumDriver
and PortProber
for cleaner code (#14589).
Added PAC proxy URL support for Selenium Manager to expand proxy configuration capabilities (#14506).
Added more internal logging for CDP, and configured WebDriver HTTP client settings for enhanced performance (#14668, #13286).
Explore the various configuration parameters for the WebDriver HTTP client.
Removed deprecated EdgeService parameters and eliminated Python 2.x code from various test files (#14563, #14502).
Set consistent polling for WebDriverWait
methods to align behavior between Java and Python implementations (#14626).
Improves binding extensibility for seamless integration of Selenium into Appium’s Python client. (#14587).
Closed BiDi WebSocket connection on session end, improving session management in BiDi (#14507).
Fixed issues with sendKeys
command, addressing errors in FileDetector
handling (#14663).
Added RBS type support for BiDi-related classes, aligning with updates for Ruby BiDi compatibility (#14611).
Updated BiDi script structures to match recent specifications for consistent implementation (#14236).
New Grid UI features for sorting and WebSocket management, adding clarity and control to session management (#14571, #14598, #14599).
Enabled async requests in httpclient
to enhance request handling performance (#14409).
Improved node handling for better scalability and stability (#14628).
Updated FFmpeg v7.1 in video recorder (#2439).
Updated in Helm chart for Selenium Grid deployment to Kubernetes
Special shout-out to everyone who helped the Selenium Team get this release out!
Swastik Baranwal
Rob Brackett
Michael Render
Agustin Pequeno
David Bernhard
Priyansh Garg
Alex
Navin Chandra
Simon Benzer
Abdelrahman Magdy Ellithy
Swastik Baranwal
ian zhang
Harshit Bhardwaj
Pallavi
Simon Benzer
Andrew Zipperer
Bruno Brito
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Viet Nguyen Duc
This year marks a monumental milestone—20 years of Selenium transforming browser automation! Since its inception as a modest open-source project, Selenium has grown into the world’s most trusted tool for web automation, powering testing and development for countless users globally. From revolutionizing open-source collaboration to shaping automation practices, Selenium has impacted developers, testers, and organizations worldwide.
To honor this journey, the Selenium team hosted a special webinar on October 28th, 2024, where the leadership team shared insights on Selenium’s evolution, the latest advancements in WebDriver BiDi, and exciting prospects for the future. If you’d like to learn more about Selenium’s incredible journey and future plans, head to the official blog post here.
Special thanks to the Selenium community for your continued support and contributions, to the entire Selenium team for their dedication and hard work, and to Pallavi Sharma and Maaret Pyhäjärvi for organizing and leading this event.
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy automating!
This year marks a monumental milestone—20 remarkable years of Selenium, the tool that revolutionized browser automation! We’re thrilled to invite you to a special event to commemorate this incredible journey: Celebrating 20 Years of Selenium
Two Decades of Selenium: Revolutionizing Open Source Browser Automation and Testing Over the past two decades, Selenium has reshaped the automation landscape, evolving from a simple tool into the backbone of browser automation across the globe. What began as a modest open-source project has grown into the most trusted tool for web automation, embraced by developers, testers, and businesses alike. As we celebrate Selenium’s 20th birthday on October 28th, we invite you to join a special webinar that honors the tool itself and the incredible community that has powered its success. Governed by the Software Freedom Conservancy, Selenium’s legacy is built on open-source collaboration and the passion of its contributors. The webinar begins at 11:30 AM GMT on October 28th, 2024, and will be packed with two hours of insightful talks from the Selenium Leadership Team. We’ll explore the project’s current advancements, the cutting-edge work in the WebDriver BiDi space, and what lies ahead for the next decade of Selenium. Here’s what you can expect:
Meet the Speakers:
Diego Molina – Selenium Project Leadership & Technical Leadership Topic: “Choosing the Right Framework: Exploring the Selenium Ecosystem for Testing” Diego will dive into a critical discussion on Selenium’s role in the broader testing ecosystem. He’ll explore whether Selenium remains the best option for web testing, considering the wide array of available frameworks. Expect valuable insights into Selenium’s advantages, limitations, and how to choose the right tool for your needs.
Puja Jagani – Selenium Technical Leadership Topic: “BiDi-powered Selenium: Shaping Tomorrow’s Automation” Puja, a leading contributor to the WebDriver BiDi initiative, will give us a glimpse into the future of automation. Her talk will explore how the W3C BiDi protocol transforms browser automation with event-driven testing capabilities, offering improved performance and cutting-edge features that will redefine the automation landscape.
Q and A - With Folks From Selenium Project
Why You Should Attend This webinar is more than just a celebration—it’s a chance to learn from the visionaries driving Selenium’s evolution. Whether you’re a seasoned professional or new to browser automation, this event offers invaluable insights into Selenium’s past, present, and future. 💻 Event Registration: Celebrating 20 Years of Selenium 📅 Date & Time: October 28th, 2024, at 11:30 AM GMT
Join Us in Celebrating Selenium’s Incredible Journey! For 20 years, Selenium has helped shape how we test, automate, and innovate on the web. This is your opportunity to celebrate that legacy and learn what the future holds for browser automation. We can’t wait to see you there! Event Organizers - Maaret, Diego, and Pallavi.
Couldn’t join us live? Watch the entire “Celebrating 20 Years of Selenium” event on YouTube. Relive the milestone moments, hear directly from the Selenium leadership team, and get insights into the future of browser automation.
📹 Recording Link: Watch the Event Recording on YouTube
This recording covers the highlights, including discussions on Selenium’s evolution, its role in the testing ecosystem, and the exciting advancements in WebDriver BiDi.
We’re thrilled to announce that SeleniumConf & AppiumConf is returning for 2025, bringing together browser and mobile automation enthusiasts from around the world. This must-attend event will take place from March 26-28, 2025, in the vibrant city of Valencia, Spain!
This year, the conference will gather over 400 browser and mobile automation professionals, including developers, testers, quality managers, test architects, and others, to explore the latest trends in browser and mobile automation, including cutting-edge topics like AI in automation, game testing, accessibility automation, and much more. Whether you’re new to automation or an experienced professional, this conference is designed to offer actionable insights and practical knowledge that you can take back to your team.
Excited about SeleniumConf & AppiumConf 2025? Share this event with your colleagues, friends, and fellow automation enthusiasts. Remember to follow us for updates and visit www.seleniumconf.com to learn more.
Happy testing!
We’re very happy to announce the release of Selenium 4.25 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
Selenium 4.25.0 introduces several important changes and improvements across multiple programming languages and build systems. Below are the key highlights from this release.
Chrome DevTools support is now: v129, v128, and v127 (Firefox still uses v85 for all versions)
Selenium has at least 4M active users in the last 30 days. 1.5M more than 4 months ago!
First implementation of BiDi (Bidirectional WebDriver Protocol) for .NET, providing advanced capabilities like inspecting browser contexts and receiving real-time events.
var bidi = await driver.AsBiDiAsync();
to get started.Escape cookie values when required for tests (#14486)
Warn about an upcoming change enforcing string quotes in TOML (#14491)
Fixed type errors for pointer_input.py
, wheel_input.py
, and firefox/options.py
(#14476)
Fixed failing BiDi tests (#14448)
Dropped support for Python 2.x in firefox_profile.py
(#14489)
Fixed flaky network event tests for BiDi (#14512)
Closed CDP websocket connection on driver.quit
(#14501)
BiDi API updates, including renaming methods and simplifying context handling (#14318)
Exposed BiDi associated references in browsing context (#14495)
Allowed driver path to be set using environment variables (#14287)
Fixed the add_cause
method not being able to process an array of hashes (#14433)
KEDA Scaler in Kubernetes:
username
, password
) for the Grid GraphQL endpoint (#2401).nodeMaxSessions
parameter to control maximum concurrent sessions per node, aligning with the node config --max-sessions
(#2402).Note: The above KEDA scaler updates are available experimentally via our built images approach. Check out this for more details.
Selenium Grid Helm Chart: Updated to support the new KEDA scaler enhancements.
Special shout-out to everyone who helped the Selenium Team get this release out!
Swastik Baranwal
Agustin Pequeno
Angie Jones
Chris Gossett
Dominic Evans
Manuel Blanco
Navin Chandra
Sandeep Suryaprasad
Simon Benzer
Agustin Pequeno
Pallavi
Simon Benzer
Markus Kopp
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Viet Nguyen Duc
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy automating!
We’re very happy to announce the release of Selenium 4.24.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
Newtonsoft.Json
to System.Text.Json
package.pyproject.toml
.GLOBAL_DEFAULT_TIMEOUT
.Special shout-out to everyone who helped the Selenium Team get this release out!
MustafaAgamy
Agustin Pequeno
Angie Jones
Chris Gossett
Diogo Teles Sant'Anna
Dominic Evans
Alex
Lauro Moura
Manuel Blanco
Michael Mintz
Navin Chandra
Pavel Sobolev
Sandeep Suryaprasad
Simon Benzer
MustafaAgamy
Agustin Pequeno
ian zhang
Pedro Aguiar
Jochen
Pallavi
Pablo Martinez
Scott Babcock
Simon Benzer
Marek Andreansky
Ilia Lazebnik
Trig
Nandor Pal
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Viet Nguyen Duc
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy automating!
The HtmlUnit Remote project implements a W3C WebDriver protocol wrapper for HtmlUnitDriver, which enables Selenium 4 Grid to supply remote sessions of this headless browser.
To eliminate behavioral differences between local and remote configurations, the Selenium Foundation framework always acquires browser sessions from a Grid instance, managing its own local grid instance when not configured to use an existing grid. Selenium 3 Grid could be configured to supply HtmlUnitDriver sessions, supported by special-case handling within the Node server itself. This handling was not carried over into Selenium 4 Grid, which was completely re-engineered with new architecture and vastly expanded capabilities.
The lack of HtmlUnitDriver support in Selenium 4 Grid necessitated reconfiguring the Selenium Foundation project unit tests from using this Java-only managed artifact to using a standard browser like Chrome, an external dependency that requires additional resources and imposes additional risks of failure.
The driver service implemented by HtmlUnit Remote enables Selenium 4 Grid to supply HtmlUnitDriver sessions.
My initial objective for creating HtmlUnit Remote was to retain feature parity in Selenium Foundation for the set of browsers supported with Selenium 3 and Selenium 4. Although I could configure my unit tests to target a conventional browser, I also wanted to avoid additional external dependencies with associated risks.
Once I began investigating the features and functionality I would need to enable Selenium 4 Grid to supply HtmlUnitDriver sessions, I recognized an additional benefit this project could provide - comprehensive standardized configurability.
All remote drivers are configured via a standard Selenium feature - the Capabilities object. Prior to the HtmlUnit Remote project, many of the options of HtmlUnit could not be accessed or modified via the Capabilities API. These were only available via custom HtmlUnitDriver methods, and the way that non-standard capabilities had been added to the Capabilities object didn’t conform to the W3C specification.
This meant that the initial phase of the HtmlUnit Remote project was to implement a comprehensive W3C-compliant configuration object - the HtmlUnitDriverOptions class. This class extends AbstractDriverOptions, adding driver-specific capabilities under an extension named garg:htmlunitOptions
. Support for this class provides full configurability of all HtmlUnitDriver options through the standard Capabilities API.
This standardized configuration API has been incorporated directly into HtmlUnitDriver, providing the core implementation for manipulating every driver setting. To maintain backward compatibility, all of the existing constructors and configuration methods have been retained, reimplemented to use this new core API.
With full standardized configurability in place, the next step was to create a server that implements the W3C WebDriver protocol. The HtmlUnitDriverServer functions as a remote protocol wrapper around one or more HtmlUnitDriver sessions, performing the following tasks:
Rather than bulk up the existing driver with remote-specific features, HtmlUnitDriverServer and associated facilities are packaged in a companion htmlunit-remote
artifact. In addition to the server, this artifact defines a driver information provider (HtmlUnitDriverInfo), a driver service (HtmlUnitDriverService), and a custom slot matcher (HtmlUnitSlotMatcher).
Next up is HtmlUnitDriverInfo, which specifies the basic characteristics of the driver and provides a method that creates a driver session with specified capabilities. This class implements the standard WebDriverInfo interface.
With availability of HtmlUnitDriver advertised by this information provider, Selenium 4 Grid nodes can be configured to provide driver sessions:
[node]
detect-drivers = false
[[node.driver-configuration]]
display-name = "HtmlUnit"
stereotype = "{\"browserName\": \"htmlunit\"}"
[distributor]
slot-matcher = "org.openqa.selenium.htmlunit.remote.HtmlUnitSlotMatcher"
The selenium-server
JAR doesn’t include the HtmlUnitDriver artifacts; these need to be specified as extensions to the grid class path via the --ext
option:
java -jar selenium-server-<version>.jar --ext htmlunit-remote-<version>-grid-extension.jar standalone --config htmlunit.toml
The grid-extension
artifact provides all of the specifications and service providers required to enable Selenium 4 Grid to supply remote sessions of HtmlUnitDriver. This artifact combines htmlunit-remote
with htmlunit3-driver
, htmlunit
, and all of their unique dependencies.
HtmlUnit Remote provides the following elements:
htmlunit
as the browser name.In operation, HtmlUnitDriverService is instantiated by Selenium 4 Grid node servers that are configured to support HtmlUnitDriver. Unlike other driver services, which launch a new process for each created driver session, HtmlUnitDriverService starts a single in-process server that hosts all of the driver sessions it creates.
This is a guest blog post by Scott Babcock
Starting with version 127 of Chrome, the browser now asks which search engine you would like to use, which is great for regular users.
But for automation, it does so every single time.
To bypass this, use the argument below when specifying the browser options.
--disable-search-engine-choice-screen
The second feature is something that has been with Chrome for quite a while now.
Every time you launch Chrome, it will query and download several .crx files.
These files can even be left over on your disk’s download folder if you create and close drivers faster than these can be processed.
To disable this feature, use the browser option below.
--disable-features=OptimizationGuideModelDownloading,OptimizationHintsFetching,OptimizationTargetPrediction,OptimizationHints
This is a guest blog post by Marek Andreansky
The Selenium Project has always been fully supportive of creating a standard to improve the quality of the web that we use. We started with the WebDriver Specification and over the last couple of years have been working with the Safari, Edge, Chrome, and Firefox teams on the WebDriver-BiDi specification.
Today, we are celebrating that Puppeteer has moved over to using WebDriver-BiDi, the new WebDriver Specification that allows WebDriver clients to have event driven APIs instead of the synchronous way Selenium has done it before.
This new protocol allows us to be able to do things Selenium always wanted to do but was never surfaced to us in a meaningful way. We have documented all the latest additions to Selenium, thanks to WebDriver-BiDi, in our documentation
You can read about the latest changes on Mozilla Hacks and on the Chrome Developer Blog.
Congratulations to everyone in making this a reality and supporting a standardised web!
Over the last week there have been stories going around about crypto miners abusing unsecured Selenium Grids by injecting code in the session create to download and start up crypto miners. This came out thanks to the work from Wiz about an attack they have called SeleniumGreed. This issue can be abused on most versions of Selenium but there appears to be a lot of effort going into abusing Selenium Grid 3.14. Please upgrade as some of the security items have been added since then.
Selenium Grid by default doesn’t have any authentication as the assumption has always been that we want you to put this behind a secure network to prevent people from abusing your resources. There are ways that you can secure the grid, and we have documentation available on how to do this in our help section. You can see more details if you run
java -jar selenium-server-<version>.jar info security
Another way to combat this is to use a cloud provider to run your Selenium Grid. We have numerous vendors that sponsor us so have a look at our sponsors page. If you need help, after reading the help section please come into our chat rooms and we will try guide you through making your grid more secure.
We’re very happy to announce the release of Selenium 4.23.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
Special shout-out to everyone who helped the Selenium Team get this release out!
Viet Nguyen Duc
Agustin Pequeno
Alex
ian zhang
Agustin Pequeno
Pallavi
Viet Nguyen Duc
Werner Robitza
Sebastian Schreck
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy automating!
Selenium has witnessed an exceptional year filled with expansion and progress. The rising popularity of Selenium’s Python Bindings is prominently showcased through the engaging discussions at the Selenium Conference and on LinkedIn. Concurrently, the Java bindings have reached a significant landmark, surpassing 100 million downloads. In addition to this, the community has managed to garner over 2.5 million active Selenium users monthly.
We could not have achieved Selenium’s 20th anniversary without the collective efforts of numerous volunteers and the invaluable assistance of a company like Sauce Labs.
In 2008, Jason Huggins, Selenium’s creator, established Sauce Labs, a company that has since played a crucial role in Selenium’s expansion.
Sauce Labs has provided a platform for the Selenium Project to display its accomplishments, including various keynotes at SauceCon. Here, figures like Simon Stewart and Jim Evans have been able to share their visions for the future of Selenium.
Financially, Sauce Labs has substantially supported the Selenium Project, sponsoring both the project itself and the Selenium Conference over many years. This backing has been instrumental in allowing the project to flourish.
Selenium thrives on collaboration, and Sauce Labs has been a vital facilitator. They have enabled the Selenium Project to host in-person events like the Test Automation Summit in Berlin in 2022. These gatherings have provided opportunities for members of the Selenium Project to engage with creators of different testing frameworks, fostering discussions on ecosystem improvements. Sauce Labs has also hosted Selenium Dev Summits, where the project’s future has been a central topic.
Sauce Labs contributions extend beyond financial support. They have significantly contributed to the technical and organizational well-being of the Selenium Project. Boni Garcia developed the first version of Selenium Manager while at Sauce Labs. Furthermore, several Sauce Labs employees, including Marcus Merrell, Diego Molina, and Titus Fortner, continue contributing to the Selenium project, driven by their passion. This passion is shared by Sauce Labs, enabling these contributions to be part of their daily work.
This unwavering support has nurtured a project governed openly, not by a single entity, but by the community. This model has welcomed diverse contributors, including Google Chrome, Microsoft, Apple, LambdaTest, Applitools, BrowserStack, and Mozilla Firefox teams. Together, they have developed WebDriver BiDi, the next generation of WebDriver.
The project’s open governance and collaborative nature have allowed continuous work on client bindings, particularly WebDriver BiDi, community support, documentation improvements, and maintenance of additional projects.
Sauce Labs has been an unnamed development partner for the Selenium Project for many years. With this in mind, the Selenium Project now shows its appreciation to Sauce Labs for their years of continued support by creating a new sponsorship tier called the Development Partner and naming Sauce Labs the first and official Development Partner.
Sauce Labs has Selenium in its DNA, and Selenium has Sauce Labs in its DNA. This partnership celebrates their shared history and future. We are excited to see what the future holds for both Selenium and Sauce Labs, and we are excited to continue to work together for the next twenty years.
If you want to learn more about this partnership and win a limited edition t-shirt, check How Did Sauce Labs Get Its Name? A Selenium Story.
It has been a great year for the Selenium community as it continues to grow. The popularity of Selenium’s Python Bindings is evident from the discussions at the Selenium Conference and on LinkedIn, while the Java bindings have impressively surpassed 100 million downloads.
This project, having reached 20 years old this year, would not be possible without the amazing contributions from our volunteer contributors and the Open Source Program Offices of companies like BrowserStack that allow us to work on this project as part of our day jobs.
About BrowserStack They have over 50,000 organizations and 6M users using their end-to-end testing platform. BrowserStack has been one of the Selenium project’s biggest supporters for years and currently employs several of Selenium’s core maintainers, donating a significant portion of their time towards the development, maintenance, support, and leadership of open-source Selenium repos.
This dedicated support has allowed us to continue work on the client bindings, especially the work going into WebDriver BiDi, support our community, continuously improve our documentation, and maintain all the extra projects we oversee, ensuring Selenium can continue to thrive for the next 20 years. We are also thrilled to highlight the collaborative efforts between the BrowserStack team, the Google Chrome team, Microsoft, Apple, SauceLabs, and the Firefox team, who have come together to build Selenium WebDriver BiDi, the next generation of Selenium. This collaborative spirit embodies our dedication to enhancing the testing experience for the Selenium user community. With this in mind, the Selenium Project now shows our appreciation to BrowserStack for their years of continued support by creating a new sponsorship tier called the Development Partner. We are deeply indebted to BrowserStack for all their support and are proud to recognize them as our first official Development Partner. This work has allowed us to continue progress on the client bindings, especially the work going into WebDriver BiDi, support our community, continuously improve our documentation, and maintain all the extra projects we oversee, so Selenium can continue to be around for the next 20 years!
We’re very happy to announce the release of Selenium 4.22.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
enableBiDi()
on an Options class instance.se:videoName
capability.enable_bidi()
property of an Options class instance to True
.Special shout-out to everyone who helped the Selenium Team get this release out!
Andrei
Viet Nguyen Duc
Agustin Pequeno
Alex
Alexander Millin
Scott Babcock
Vladislav Velichko
James Yuzawa
ian zhang
Agustin Pequeno
Joshua Yam
Pallavi
Sang Nguyen
Viet Nguyen Duc
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy automating!
We’re very happy to announce the landing of Multi-Arch Images for Selenium Grid Server on the Selenium Docker Hub registry!
For experimental Docker container images that are able to run on platforms such as the Apple M-series or Raspberry Pi, the community-driven repository initiative hosted at SeleniumHQ-Community/docker-seleniarm. These images are built for separate architectures: linux/arm64 (aarch64), linux/arm/v7 (armhf), and linux/amd64 and published on Seleniarm Docker Hub registry.
In order to bring more awareness to the existence of the Multi-Arch Docker container images, provide more insight and transparency on how the container images are built, as well as overcome challenges in building and maintaining them. We have decided to merge the fork into the main project Docker Selenium and published multi-arch images on Selenium Docker Hub registry.
From image tag releases 4.21.0
onwards, the architectures
supported by Docker Selenium as below
Architecture | Operating System | Available |
---|---|---|
x86_64 (aka amd64) | Ubuntu LTS | ✅ |
aarch64 (aka arm64/armv8) | Ubuntu LTS | ✅ |
armhf (aka arm32/armv7l) | N/A | ❌ |
Based on the architecture of the host machine, Docker will automatically pull the correct image for the platform.
Let’s take a moment to look at the browser binaries which are available for various architectures
Google does not build Chrome (google-chrome) for Linux/ARM platforms. Hence, the Chrome (node and standalone) images are only available for AMD64. Similarly, Microsoft does not build Edge (microsoft-edge) for Linux/ARM platforms.
Instead, the open source Chromium browser is used in place of Chrome and Edge. The standalone-chromium
and node-chromium
$ docker run --rm -it -p 4444:4444 -p 5900:5900 -p 7900:7900 --shm-size 2g selenium/standalone-chromium:latest
Mozilla Firefox now is available for Linux/ARM64 via Nightly channel. The Firefox version in the ARM64 image will be different from the AMD64 version until the stable release is available.
Image Name | Operating System | amd64 | arm64 |
---|---|---|---|
standalone-chromium | Ubuntu LTS | ✅ | ✅ |
node-chromium | Ubuntu LTS | ✅ | ✅ |
standalone-firefox | Ubuntu LTS | ✅ | ✅ |
node-firefox | Ubuntu LTS | ✅ | ✅ |
standalone-edge | Ubuntu LTS | ✅ | ❌ |
node-edge | Ubuntu LTS | ✅ | ❌ |
standalone-chrome | Ubuntu LTS | ✅ | ❌ |
node-chrome | Ubuntu LTS | ✅ | ❌ |
We would also like to share what has been done to ensure that the multi-arch images can be built, tested, and distributed seamlessly.
Utilize Bash scripts and Makefile to wrap the tasks as much as possible. It provides the transparency on how the container images are built and proceed by single command.
Utilize Arm VM’s support on CircleCI to build, test, and deploy ARM64 images. Once GitHub Actions officially supports Arm-based hosted runners, those workflows can easily be moved back to the same place. All the tests done for AMD64 images (including Docker, Docker Compose, and deploy to Kubernetes) are used to verify ARM64 images.
Utilize experimental feature containerd image store in Docker Engine to build and distribute multi-arch images in a simple way.
Hopefully, this will make it easy for the community to find and use multi-arch images to simplify Selenium Grid Server deployment on various platforms.
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy testing!
We’re very happy to announce the release of Selenium 4.21.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
selectVisibleByText
method is same as other languagesSpecial shout-out to everyone who helped the Selenium Team get this release out!
Viet Nguyen Duc
Alex
Joe Bandenburg
Oleksandr Kulychok
Sandeep Suryaprasad
Arpan
Agustin Pequeno
Chamila Ambahera
Pallavi
Viet Nguyen Duc
Thanks as well to all the team members who contributed to this release:
Puja Jagani
Diego Molina
Boni García
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Simon Stewart
Titus Fortner
David Burns
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy testing!
We’re very happy to announce the release of Selenium 4.20.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
Special shout-out to everyone who helped the Selenium Team get this release out!
Trig
Viet Nguyen Duc
Sakif
Viet Nguyen Duc
Agustin Pequeno
Harshit Bhardwaj
Pallavi
Andrew Zipperer
Viet Nguyen Duc
Maxim Manuylov
Thanks as well to all the team members who contributed to this release:
Puja Jagani
Diego Molina
Boni García
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Simon Stewart
Titus Fortner
David Burns
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy testing!
We’re very happy to announce the release of Selenium 4.19.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
se:bidi
was removed from the session response when starting a Grid session, as webSocketUrl
is enough.WebDriverListener
.setFiles
command of the Input Module, between others.setFiles
command of the Input Module, between others.ChromiumDriverService.AllowedIPAddresses
name was correctedinstall_addon()
(Firefox extensions) was improved to take into account dir paths with trailing slashesSpecial shout-out to everyone who helped the Selenium Team get this release out!
Adam Dangoor
Agustin Pequeno
Scott Babcock
Jani Hautakangas
Alpha
Amar Deep Singh
Mohammad Monfared
Viet Nguyen Duc
Cedric Roijakkers
Maxim Manuylov
Mårten Svantesson
Thanks as well to all the team members who contributed to this release:
Puja Jagani
Diego Molina
Boni García
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Simon Stewart
Titus Fortner
David Burns
Stay tuned for updates by following SeleniumHQ on X (Formerly Twitter) or LinkedIn!
Happy testing!
Selenium WebDriver BiDi APIs in Java bindings are impacted.
The WebDriver BiDi APIs stay as they are, so you can continue to use them. However, the import statements need to be updated.
The import statements need to be updated when using the BiDi APIs.
import org.openqa.selenium.bidi.LogInspector;
import org.openqa.selenium.bidi.BrowsingContextInspector;
import org.openqa.selenium.bidi.Input;
import org.openqa.selenium.bidi.Script;
import org.openqa.selenium.bidi.Network;
import org.openqa.selenium.bidi.module.LogInspector;
import org.openqa.selenium.bidi.module.BrowsingContextInspector;
import org.openqa.selenium.bidi.module.Input;
import org.openqa.selenium.bidi.module.Script;
import org.openqa.selenium.bidi.module.Network;
Selenium is actively working to implement the W3C BiDi. The long-term goal of W3C BiDi is to port all W3C WebDriver Classic APIs to use the WebDriver BiDi APIs under the hood. When browsingContext.locateNodes command, which is the BiDi counterpart of findElements command, was introduced, the major goal was to ensure that the ’locateNodes’ command returns a WebElement. This would be make the porting smoother in the future and allows users to continue calling APIs of the WebElement.
During the implementation, a circular dependency was encountered in the underlying build tool Bazel. The solution to this was to follow the best practices of Bazel.
So, the W3C BiDi related classes of a module were grouped into Bazel package. The classes that themselves call commands or events were all grouped under a package named ‘module’. Thus, following the recommended practice and avoiding Bazel’s circular dependency proved to be a win-win solution.
The W3C BiDi protocol is in under development, and parallelly browsers and clients are working to add the complementary APIs. While Selenium works on implementing it, the protocol is constantly changing, with new modules or APIs being added or existing ones being updated. While the team strives to avoid breaking changes and deprecate APIs for at least 2 versions before removal, it can be challenging to adhere to this for some changes, such as the one described in this blog post.
We’re very happy to announce the release of Selenium 4.18.0 and 4.18.1 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
--headless=new
(see: Headless is going away)WebDriverListener
.WebDriverListener
.continuewithAuth
, between others.continuewithAuth
, between others.RemoteWebDriver
.Special shout-out to everyone who helped the Selenium Team get this release out!
Trig
Manuel Blanco
Oleg Ridchenko
Simon Perepelitsa
Simon K
Valery Yatsynovich
Michal Nowierski
Mohammad Monfared
我的饭
Nikolay Borisenko
Pallavi
Cani
Bas M.
Viet Nguyen Duc
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
We’re very happy to announce the release of Selenium 4.17.0 for Javascript, Ruby, Python, .NET, Java and the Grid! Links to everything can be found on our downloads page.
SE_AVOID_STATS
to "true"
to avoid sending information.--headless=new
(see: Headless is going away)Special shout-out to everyone who helped the Selenium Team get this release out!
Andrei Solntsev
James Braza
Lauro Moura
Valery Yatsynovich
Viet Nguyen Duc
Henrik Skupin
Yevgeniy Shunevych
Auto81
Amar Deep Singh
Viet Nguyen Duc
Thanks as well to all the team members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
The easiest way to clickbait a blog post about automated testing is to compare Selenium against another tool in the space with a catchy title especially when it talks down about the incumbent.
Unfortunately, this can lead to muddying the waters of which features are available in any of the products out there especially when we compare apples to apples.
Selenium has always been a great tool for browser automation. Fortunately for the project, it has become the tool of choice for testing web applications for nearly 2 decades. The area this project has focused on is building out the hard parts of browser automation that are increasingly difficult. Stable APIs and scalability of the infrastructure to run Selenium has always been the priority of the project. It hasn’t focused on how people test with it because there are very good test frameworks out there and having to do it for 5 different languages is a non-trivial amount of engineering effort.
However, some particular misconceptions regularly reappear across these blog posts.
This used to be true in the past as you had to download the drivers. This wasn’t too bad for GeckoDriver and SafariDriver as they could handle browser upgrades gracefully. On the other hand, you need to update the drivers for Chromium-based browser for every new release.
For over a year now, Selenium handles this automatically. If it can’t find a ChromeDriver or EdgeDriver, it will download it using Selenium Manager. Since its first release it has improved a lot and it is now probably the best in class since the latest versions of Selenium will even download browsers if it can and use that. Compared to Playwright and Cypress you don’t need to update your dependency on Selenium to update browsers and drivers, you still use the same browsers as your customers, and switching versions becomes a breeze: you don’t also have to change the test framework you’re using. And, let’s not forget that it uses the browser that Google recommends you use for testing.
Well… maybe? Setting up E2E test frameworks with Selenium isn’t as difficult as some might suggest. The hard part really is making sure that the driver is in the right place and we’ve solved that as discussed above. Once that’s done, Selenium’s approach allows you to use whichever test runner you’re most comfortable with. If you’d like a “batteries included” approach, with Selenium tightly integrated with the test runner, then one of the many projects that use Selenium, such as SeleniumBase, Nightwatch, Serenity, and so on, might be the right tool for you.
One thing to note is that Playwright is the only multi-language browser automation framework like Selenium. However, if you don’t use TypeScript or JavaScript you will still need to do the setup of the test runner yourself. Some testing frameworks have plugins that automatically set up the fixtures you might need. In the JavaScript/TypeScript space if you really need a built-in test runner there are downstream projects like NightwatchJS and tangential projects like WebdriverIO. Downstream projects use our libraries and tangential projects have their own libraries but still follow the WebDriver standard.
Selenium has been able to offer this since Selenium 4 came out. It’s so good that even Playwright suggest you use it for scaling your tests. The Selenium Project won’t be removing this anytime soon as we are dependent on WebDriver BiDi specification being implemented for those features to replace them. Even then Selenium has a history of trying to make sure that upgrades don’t break anything without sufficient warning. It’s why each language provides high-level wrappers, such as the NetworkInterceptor
, that isolate your tests from the underlying technology being used.
As we have seen from the above Selenium is still as good as the products out there. One thing that is different for Selenium from Cypress or Playwright is that we’re a volunteer-driven project and not commercially backed. Want to help us out? Why not write a blog post about how you’re using the features above or post on social media how these features make your lives easier?
Decorating the webdriver
new EventFiringWebDriver(driver); // Old approach
new EventFiringDecorator().decorate(driver); // New approach
One may find the need to have their own custom implementations be used for underlying decorated method calls. An example may be wanting to use your own findElement implementation to store metadata from web elements. One can go down a deep rabbit hole of decorators ( extending WebDriverDecorator and such ), so to keep things simple we will extend EventFiringDecorator since we want a single decorator to handle all our listener events.
public class WebDriverWrapper implements WebDriver {
private final WebDriver driver;
WebDriverWrapper(WebDriver driver) {
this.driver = driver;
}
// custom implementation goes here
@Override
public WebElement findElement(final By by) {
// custom implementation goes here
return driver.findElement(by);
}
}
public class testDecorator extends EventFiringDecorator<WebDriver> {
@Override
public Object call(Decorated<?> target, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if ("findElement".equals(methodName)) {
WebDriverWrapper newDriver = new WebDriverWrapper((WebDriver) target.getOriginal());
return newDriver.findElement((By) args[0]);
}
return super.call(target, method, args);
}
}
Some notes about the above example, we are only overriding the ‘general’ call method and checking the method name against every call made. Without going too deep decorators one can also override calls made by class instances to offer a more targeted approach. Just to expose some more functionality, let’s modify our example. We can modify WebElement context since we might care about child elements and elements found by WebDriver ( WebDriver and WebElement both extend the SearchContext ).
public class WebElementWrapper implements WebElement {
private final WebElement element;
WebElementWrapper(WebElement element) {
this.element = element;
}
@Override
public WebElement findElement(final By by) {
// custom implementation goes here
return element.findElement(by);
}
}
public class WebElementDecorator extends EventFiringDecorator<WebDriver> {
@Override
public Decorated<WebElement> createDecorated(WebElement original) {
return new DefaultDecorated<>(original, this) {
@Override
public Object call(Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if ("findElement".equals(methodName)) {
// custom implementation goes here
WebElementWrapper element = new WebElementWrapper(getOriginal());
return element.findElement((By) args[0]);
}
return super.call(method, args);
}
};
}
}
In the sample above, we are still doing a very similar approach of overriding the call method but now we are also targeting WebElement instances.
new EventFiringWebDriver(driver).register(listener1).register(listener2); // Old approach
new EventFiringDecorator(listener1, listener2); // New approach
A quality of life change that is featured in WebDriverListener class is the use of ‘default’.
In Java, the default
keyword, when used in the context of an interface method, indicates that the method has a default implementation.
If a class implementing the interface chooses not to override the method, it will inherit the default implementation.
This change allows for splitting up listeners without needing to implement the unnecessary methods you don’t need or care about.
// Old approach
public class AlertListener implements WebDriverEventListener {
@Override
public void beforeAlertAccept(final WebDriver driver) {
// custom implementation goes here
}
// implement every method in interface
}
// New approach
public class AlertListener implements WebDriverListener {
@Override
public void beforeAccept(Alert alert) {
// custom implementation goes here
}
// does not need to implement every method in interface
}
A change that was brought on is the ability to listen to generic events. One use case is logging information in a parallelized test suite. Rather than create a listener and override every method to add a simple log statement, there is now a simpler alternative of overriding one method call. Below I override beforeAnyCall, but afterAnyCall exists as well which also has the results of the call to the decorated method.
public class Listener implements WebDriverEventListener {
private static final Logger LOGGER = Logger.getLogger(Listener.class.getName());
@Override
public void beforeAnyCall(Object target, Method method, Object[] args) {
logger.debug("Thread: " + Thread.currentThread().getName() +
" | Method Name: " + method.getName() +
" | Method Args: " + Arrays.toString(args));
}
}
There also was an addition listening to more specific generic events. Going back to the logging example, beforeAnyCall is a good method for debugging information or tracking the actions of a thread but might generate too much noise. In the same use case we might only care about WebDriver or WebElement calls. One can override instances of WebDriver and derived objects( WebElement, Alert, etc.) for before/after events.
public class Listener implements WebDriverEventListener {
private static final Logger LOGGER = Logger.getLogger(Listener.class.getName());
@Override
public void beforeAnyWebDriverCall(WebDriver driver, Method method, Object[] args) {
logger.debug("Thread: " + Thread.currentThread().getName() +
" | Method Name: " + method.getName() +
" | Method Args: " + Arrays.toString(args));
}
@Override
public void beforeAnyWebElementCall(WebElement element, Method method, Object[] args) {
logger.debug("Thread: " + Thread.currentThread().getName() +
" | Method Name: " + method.getName() +
" | Method Args: " + Arrays.toString(args));
}
}
So that’s some general examples on how to transition your code! Happy testing!
We’re very happy to announce the release of Selenium 4.16.0 for Javascript, Ruby, Python, and Selenium 4.16.1 for .NET, Java and the Grid. Links to everything can be found on our downloads page.
browserVersion
that is different from what is found on the SystemSpecial shout-out to everyone who helped the Selenium Team get this release out!
Agustin Pequeno
Anthony Sottile
Dominik Stadler
Johnny.H
Manuel Blanco
Matthew Kempkers
Nikhil Agarwal
Daniel P. Purkhús
Viet Nguyen Duc
Henrik Skupin
Sparsh Kesari
Ed Manlove
Ronald Abegg
Tamas Utasi
Thabelo Ramabulana
Amar Deep Singh
Matt Colman
Viet Nguyen Duc
Thanks as well to all the team members who contributed to this release:
ian zhang
Boni García
Diego Molina
Sri Harsha
Luis Correia
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Simon Stewart
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
Selenium Manager 0.4.15 includes support for Firefox Extended Support Release (ESR). This way, Firefox ESR can be automatically managed with Selenium using the label esr
in the browser version. Bindings languages set this browser version (like other accepted labels for browser versions, such as stable,
beta,
dev,
canary,
and nightly
) using a browser option called browserVersion.
Selenium Manager 0.4.15 allows automated driver management for Microsoft Edge WebView2. WebView2 is a component that enables embedding web technologies (HTML, CSS, and JavaScript) in native apps, using Microsoft Edge as the rendering engine to display web content. At the time of this writing, WebView2 is available in Windows.
This way, Selenium Manager allows detecting WebView2 in Windows machines and resolving the proper msedgedriver binary for it. Internally, Selenium Manager uses the browser name webview2
to handle WebView2, detecting its version based on registry queries. In the bindings, WebView2 is enabled through a browser option called useWebView
.
Selenium Manager 0.4.15 includes a couple of new arguments in Selenium Manager for specifying custom URLs for drivers and browsers (instead of the default ones, such as chromedriver, Chrome for Testing, etc.). These arguments are:
--driver-mirror-url
: Mirror URL for driver repositories.--browser-mirror-url
: Mirror URL for browser repositories.As usual, these values can be configured using the config file or environment variable (e.g., SE_DRIVER_MIRROR_URL
or SE_BROWSER_MIRROR_URL
). Moreover, there are browser and driver-specific configuration keys, i.e. chrome-mirror-url
, firefox-mirror-url
, edge-mirror-url
, etc. (in the configuration file), and SE_CHROME_MIRROR_URL
, SE_FIREFOX_MIRROR_URL
, SE_EDGE_MIRROR_URL
, etc. (as environment variables).
Here is an example of this feature calling Selenium Manager from the shell:
./selenium-manager --debug --browser chrome --browser-version 100 --avoid-browser-download --driver-mirror-url=https://registry.npmmirror.com/-/binary/chromedriver/
DEBUG chromedriver not found in PATH
DEBUG chrome detected at C:\Program Files\Google\Chrome\Application\chrome.exe
DEBUG Running command: wmic datafile where name='C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' get Version /value
DEBUG Output: "\r\r\n\r\r\nVersion=117.0.5938.150\r\r\n\r\r\n\r\r\n\r"
DEBUG Detected browser: chrome 117.0.5938.150
DEBUG Discovered chrome version (117) different to specified browser version (100)
DEBUG Required driver: chromedriver 100.0.4896.60
DEBUG Downloading chromedriver 100.0.4896.60 from https://registry.npmmirror.com/-/binary/chromedriver/100.0.4896.60/chromedriver_win32.zip
INFO Driver path: C:\Users\boni\.cache\selenium\chromedriver\win64\100.0.4896.60\chromedriver.exe
INFO Browser path: C:\Program Files\Google\Chrome\Application\chrome.exe
To troubleshoot Selenium Manager in complex error cases, it is interesting to capture the backtrace. But to do that, the Selenium Manager binaries must be created with the debug symbols. Since the resulting binaries with debug symbols are much larger than the default release artifacts, we generate them on demand using a custom workflow in GitHub Actions. This way, we have included a checkbox in the workflow for triggering the Selenium Manager build. When this checkbox is enabled when building Selenium Manager, the debug symbols will be added to the resulting binaries (for Windows, Linux, and macOS). All in all, these binaries will be used on demand to troubleshoot complicated problems.
As of version 4.15.0 of the Selenium Java bindings, the Selenium Manager binary is extracted and copied to the cache folder. For instance, the Selenium Manager binary shipped with Selenium 4.15.0 is stored in the folder ~/.cache/selenium/manager/0.4.15
). This feature will allow direct manipulation of Selenium Manager as a CLI tool, for instance, for troubleshooting. This feature is only available for Java bindings since Java is the only language that does not have direct access to the Selenium Manager binaries (since they are released compressed into the JAR files of the selenium-java
artifacts).
Look at Selenium Manager documentation for a detailed description of its features. Also, you can trace the status of the development activities in the Selenium Manager project dashboard.
We’re very happy to announce the release of Selenium 4.15.0 for Java, Javascript, Ruby, .NET and the Grid; 4.15.2 for Python. Links to everything can be found on our downloads page.
Special shout-out to everyone who helped the Selenium Team get this release out!
Afranio Alves
Anselmo Pfeifer
Luis Correia
Pallavi
Sang Nguyen
Vicente Sombo
sripriyapkulkarni
Zachary Zollman
Vinicius Caetano
Luis Correia
Mårten Svantesson
Matt Colman
Philippe GRANET
sebastian haas
Viet Nguyen Duc
Thanks as well to all the Selenium Team Members who contributed to this release:
Boni García
Diego Molina
Sri Harsha
Nikolay Borisenko
Puja Jagani
Simon Stewart
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
In less than two weeks, Selenium project is holding space for free and online community meetup, the inaugural Selenium Open Space Conference. Open space conferences are ones where everyone is a speaker, and we co-create our agenda for conversations, questions or answers, workshops, sharing and learning.
We start our 24 hour event at time of 19 years from the tracked Selenium release announcement. We split the day into four segments to facilitate the global community. We set up an event site, and a mechanism to enroll: by pull request or issue to the site in github.
With enrollment, you can already tell if you have a topic in mind you would like to host, and see some (not all!) of the sessions people have in mind for the day.
To run the event, we set up Welo and Miro. Our space has 11 track rooms that each fit up to 150 people regardless of appearance, and we build our agenda on Miro during marketplace of ideas, one for each four time segments.
Welcome from the organizers, would be lovely to see you join us all.
Selenium Manager continues its development plan. As usual, in the latest releases, i.e., 0.4.13 and 0.4.14 (shipped with Selenium 4.13 and 4.14, respectively), we have fixed the problems reported so far. In these releases, the issues were related to the extraction of the Firefox binary from the self-extracting archive (SFX) in Windows and the advanced configuration through the configuration file (se-config.toml
) and environment variables (e.g., SE_BROWSER
). Moreover, these recent releases include new features, as explained below.
By default, Selenium Manager needs to request online endpoints (such as Chrome for Testing JSON API or Firefox product-details JSON API
to discover, download, and maintain the proper drivers and browsers that Selenium requires. The downloaded artifacts are stored in the cache (by default, ~/.cache/selenium
) and reused from there.
To make the driver resolution procedure more robust, as of version 0.4.13, Selenium Manager includes a new feature for locating the drivers in the cache when some error happens. This way, when a network request (or other function) fails in Selenium Manager, it tries to locate the driver in the cache. This characteristic aims to provide a best-effort solution for creating a Selenium session properly, which is the final objective of Selenium Manager. Also, this feature will help to provide a better experience for locating drivers for Selenium Grid.
The next feature related to Selenium Manager 0.4.13 has been implemented in the Selenium bindings (i.e., Java, JavaScript, Python, .Net, and Ruby). As of Selenium 4.13.0, the Selenium bindings allow locating the Selenium Manager binary using an environment variable called SE_MANAGER_PATH
. This way, if this variable is set, the bindings will use its value as the Selenium Manager path in the local filesystem. This feature will allow users to provide a custom compilation of Selenium Manager, for instance, if the default binaries (compiled for Windows, Linux, and macOS) are incompatible with a given system (e.g., ARM64 in Linux).
Selenium Manager 0.4.14 includes automated Edge management. This browser is the last we have in mind for this feature, after Chrome and Firefox.
This feature has been implemented in the same way that Chrome and Firefox for macOS and Linux. In other words, Selenium Manager allows to automatically manage (i.e., discover, downloads, and cache) the latest Edge versions (i.e., stable, beta, dev, canary) and old versions (e.g., 115, 116, etc.). The downloaded binaries, as usual, are stored in the Selenium cache. The following output commands showcase this feature in macOS (first snipped) and Linux (second snippet):
./selenium-manager --browser edge --debug --force-browser-download
DEBUG msedgedriver not found in PATH
DEBUG Checking edge releases on https://edgeupdates.microsoft.com/api/products
DEBUG Required browser: edge 117.0.2045.40
DEBUG Downloading edge 117.0.2045.40 from https://msedge.sf.dl.delivery.mp.microsoft.com/filestreamingservice/files/6e65d9ef-0bb9-4636-8d9e-2b1b9d16149d/MicrosoftEdge-117.0.2045.40.pkg
DEBUG edge 117.0.2045.40 has been downloaded at /Users/boni/.cache/selenium/edge/mac64/117.0.2045.40/Microsoft Edge.app/Contents/MacOS/Microsoft Edge
DEBUG Reading msedgedriver version from https://msedgedriver.azureedge.net/LATEST_RELEASE_117_MACOS
DEBUG Required driver: msedgedriver 117.0.2045.40
DEBUG Downloading msedgedriver 117.0.2045.40 from https://msedgedriver.azureedge.net/117.0.2045.40/edgedriver_mac64.zip
INFO Driver path: /Users/boni/.cache/selenium/msedgedriver/mac64/117.0.2045.40/msedgedriver
INFO Browser path: /Users/boni/.cache/selenium/edge/mac64/117.0.2045.40/Microsoft Edge.app/Contents/MacOS/Microsoft Edge
./selenium-manager --browser edge --debug --browser-version beta
DEBUG msedgedriver not found in PATH
DEBUG edge not found in PATH
DEBUG edge beta not found in the system
DEBUG Checking edge releases on https://edgeupdates.microsoft.com/api/products
DEBUG Required browser: edge 118.0.2088.11
DEBUG Downloading edge 118.0.2088.11 from https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-beta/microsoft-edge-beta_118.0.2088.11-1_amd64.deb
DEBUG edge 118.0.2088.11 has been downloaded at /home/user/.cache/selenium/edge/linux64/118.0.2088.11/msedge
DEBUG Reading msedgedriver version from https://msedgedriver.azureedge.net/LATEST_RELEASE_118_LINUX
DEBUG Required driver: msedgedriver 118.0.2088.11
DEBUG Downloading msedgedriver 118.0.2088.11 from https://msedgedriver.azureedge.net/118.0.2088.11/edgedriver_linux64.zip
INFO Driver path: /home/user/.cache/selenium/msedgedriver/linux64/118.0.2088.11/msedgedriver
INFO Browser path: /home/user/.cache/selenium/edge/linux64/118.0.2088.11/msedge
Nevertheless, this feature cannot be implemented similarly for Windows. The reason is that the Edge installer for Windows is distributed as a Microsoft Installer (MSI) file, designed to be executed with administrator rights. We tried to extract the Edge binaries from that MSI file. Still, it seems not possible (see Stack Overflow post that summarized the problem). All in all, the only solution we found is to install Edge in Windows using the MSI installer, and so, administrator grants are required.
This way, when Edge is attempted to be installed with Selenium Manager in Windows with a non-administrator session, a warning message will be displayed as follows:
./selenium-manager --debug --browser edge --browser-version beta
DEBUG msedgedriver not found in PATH
DEBUG edge not found in PATH
DEBUG edge beta not found in the system
WARN There was an error managing edge (edge can only be installed in Windows with administrator permissions); using driver found in the cache
INFO Driver path: C:\Users\boni\.cache\selenium\msedgedriver\win64\118.0.2088.17\msedgedriver.exe
But when Selenium Manager is executed with administrator grants in Windows, it will be able to automatically discover, download, and install Edge (stable, beta, dev, canary, and older versions):
./selenium-manager --debug --browser edge --browser-version beta
DEBUG msedgedriver not found in PATH
DEBUG edge not found in PATH
DEBUG edge beta not found in the system
DEBUG Checking edge releases on https://edgeupdates.microsoft.com/api/products
DEBUG Required browser: edge 118.0.2088.17
DEBUG Downloading edge 118.0.2088.17 from https://msedge.sf.dl.delivery.mp.microsoft.com/filestreamingservice/files/7adec542-f34c-4dea-8e2a-f8c6fab4d2f3/MicrosoftEdgeBetaEnterpriseX64.msi
DEBUG Installing MicrosoftEdgeBetaEnterpriseX64.msi
DEBUG edge 118.0.2088.17 is available at C:\Program Files (x86)\Microsoft\Edge Beta\Application\msedge.exe
DEBUG Required driver: msedgedriver 118.0.2088.17
DEBUG msedgedriver 118.0.2088.17 already in the cache
INFO Driver path: C:\Users\boni\.cache\selenium\msedgedriver\win64\118.0.2088.17\msedgedriver.exe
INFO Browser path: C:\Program Files (x86)\Microsoft\Edge Beta\Application\msedge.exe
Chromium is released as portable binaries, distributed as zip files for Windows, Linux, and macOS (see Chromium download page). Nevertheless, there is a case in which Chromium is actually installed in the system. This happens in Linux systems when installing Chromium through package managers like atp
or snap
, for instance, as follows:
sudo snap install chromium
Therefore, as of 0.4.14, Selenium Manager looks for the Chromium binaries in the PATH when Chrome is not discovered. The following snippet showcases how this feature works in a Linux machine in which Chrome is not available, but Chromium has been installed through snap
:
./selenium-manager --browser chrome --debug
DEBUG chromedriver not found in PATH
DEBUG Found chromium in PATH: /snap/bin/chromium
DEBUG Running command: /snap/bin/chromium --version
DEBUG Output: "Chromium 117.0.5938.149 snap"
DEBUG Detected browser: chrome 117.0.5938.149
DEBUG Required driver: chromedriver 117.0.5938.149
DEBUG chromedriver 117.0.5938.149 already in the cache
INFO Driver path: /home/user/.cache/selenium/chromedriver/linux64/117.0.5938.149/chromedriver
INFO Browser path: /snap/bin/chromium
We are close to implementing all the features initially planned for Selenium Manager. You can trace the status of the development activities in the Selenium Manager project dashboard.
We’re very happy to announce the release of Selenium 4.13.0 for Java, Python, Javascript and the Grid; and 4.13.1 for .NET and Ruby. Links to everything can be found on our downloads page.
SE_MANAGER_PATH
environment variable.Special shout-out to everyone who helped the Selenium Team get this release out!
Jeffery
Krishna Suravarapu
Sean Gomez
Manuel Blanco
Michael Mintz
Nikolay Borisenko
Sandeep Suryaprasad
Scott Babcock
Sparsh Kesari
eaccmk
Nikolay Borisenko
Sachin Kumar
Amar Deep Singh
Luis Correia
William Lacerda
Thanks as well to all the Selenium Team Members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Puja Jagani
Simon Stewart
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
We’re very happy to announce the release of Selenium 4.14.0 for Java, Python, Javascript, Ruby, .NET and the Grid. Links to everything can be found on our downloads page.
Special shout-out to everyone who helped the Selenium Team get this release out!
Alexey Pelykh
Manuel Blanco
Scott Babcock
ian zhang
Amar Deep Singh
Ismael Onilearan
Cody Lent
William Lacerda
Thanks as well to all the Selenium Team Members who contributed to this release:
Boni García
Sri Harsha
Nikolay Borisenko
Puja Jagani
Simon Stewart
Simon K
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
We’re very happy to announce the release of Selenium 4.12.0 for Java, .NET, Ruby, Python, and Javascript as well as the Grid. Links to everything can be found on our downloads page.
netstandard2.0
:capabilities
arguments for local drivers (must use :options
now)UNEXPECTED_ALERT_BEHAVIOR
, BROWSER_LOGFILE
, createPointerDown
, createPointerUp
and JWP /file
endpointdisableNativeEvents
and Remote Response status fieldSpecial shout-out to everyone who helped the Selenium Team get this release out!
Nikolay Borisenko
Sandeep Suryaprasad
Scott Babcock
Andrii Maliuta
Andrei Solntsev
Nikolay Borisenko
Pallavi
Tahanima Chowdhury
Veerendra Jana
Mario Segura
Thanks as well to all the Selenium Team Members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Jonathan Lipps
Luke Hill
Alex Rodionov
Puja Jagani
Simon Stewart
Simon K
Titus Fortner
Stay tuned for updates by following SeleniumHQ!
Happy testing!
A new release of Selenium Manager is out. For this release, we made a relevant decision concerning the Selenium Manager versioning format. From now on, Selenium Manager will follow the same version as Selenium. Nevertheless, since Selenium Manager is still in beta, its major version is 0. Thus, Selenium 4.12.0 is shipped with Selenium Manager 0.4.12.
First, we made a substantial effort to stabilize the already available features on Selenium Manager. This way, the version includes several bug-fixing related to automated driver management or caching. You can find the details of the changes implemented in Selenium Manager 0.4.12 in the (newly created) changelog file.
Besides, for this release, we made a significant update to the documentation page of Selenium Manager. This page contains all the fine-grained information related to automated driver and browser management, configuration, etc. Also, it has several TL;DR summarizing the main ideas for the eager reader.
After shipping automated browser management based on Chrome for Testing on the previous release, Selenium Manager 0.4.12 continues the job by providing automated Firefox management. This way, Selenium Manager 0.4.12 allows us to manage the different Firefox releases (for Windows, Linux, and macOS), making them seamlessly available for Selenium.
The procedure is the same as with Chrome. When Firefox is unavailable in the machine running Selenium, it is automatically discovered, downloaded, and cached by Selenium. If no version is specified, the latest stable Firefox release is managed by Selenium Manager. Besides, the bindings can use a browser option called browserVersion to specify a particular Firefox release (e.g., 114, 115, etc.). Finally, the label stable
allows us to manage the current stable Firefox release explicitly, and the labels beta
, dev
, and nightly
as used for unstable Firefox releases.
This feature is possible thanks to the remarkable work of the Firefox team by maintaining current and old releases in their public repository. Moreover, the Firefox version discovery in Selenium Manager is made thanks to the availability of the product-details JSON API, also maintained by the Firefox team.
Custom setup is sometimes necessary for browser automation. For that reason, Selenium Manager already provides different features for rich configuration. Selenium Manager 0.4.12 extends this feature by delivering a new configuration argument called --cache-path
. This argument allows changing the path of the local folder used to store downloaded assets (drivers and browsers) by Selenium Manager (by default, ~/.cache/selenium
). As usual, this argument can also be changed by including an entry in the configuration file or using an environment variable (SE_CACHE_PATH
). Regarding the former, the name of the configuration file has been renamed to se-config.toml
in Selenium Manager 0.4.12. As usual, if you use this configuration file, it must be placed in the root of the cache folder.
A minor change in Selenium Manager 0.4.12 is related to the metadata file, now called se-metadata.json
. As usual, this file is stored in the root of the cache folder. This file contains versions discovered by Selenium Manager making network requests and the time-to-live (TTL) in which they are valid. Since the TTL for browsers and drivers is now the same concept, Selenium Manager unifies these two configuration elements (previously, browser_ttl
and driver_ttl
) in a single one called ttl
(with a default value of 3600 seconds, i.e., 1 hour). For further details, visit the Selenium Manager page about caching.
Last but not least, the Selenium Manager binary compiled for macOS is universal, in the sense that it can be executed both in x64 and arm64 architectures out of the box. Previously, the binary was compiled for x64, and so, Rosetta should be available in arm64 macOS machines (i.e., M1 or M2). With the new Selenium Manager macOS binary, Rosetta is no longer mandatory.
The next release of Selenium Manager will continue delivering automated browser management, this time for Edge, and other features. As usual, you can trace the work in progress in the Selenium Manager project dashboard.
We’re very happy to announce the release of Selenium 4.11.0 for Java, .NET, Ruby, Python, and Javascript as well as the Grid and Internet Explorer Driver. Links to everything can be found on our downloads page.
capabilities
and set_capability
in wpewebkit/options.py (#12169)WPEWebKitService
and WebKitGTKService
in the public APIActionChains.scroll(...)
Special shout-out to everyone who helped the Selenium Team get this release out!
Michael Mintz
Nikolay Borisenko
Sandeep Suryaprasad
Hanbo Wang
Sebastian Meyer
Daniel Brown
Vedanth Vasu Dev
Bartek Florczak
João Luca Ripardo
Debanjan Choudhury
Christian Biesinger
Sen ZmaKi
Pallavi
Cristian Greco
Gayathri Rukmadhavan
Mikhail C.
nevinaydin
Erick Ribeiro
Luis Correia
alb3ric
Bartek Florczak
Mårten Svantesson
wintersolutions
Thanks as well to all the Selenium Team Members who contributed to this release:
Tamsil Sajid Amani
Diego Molina
Sri Harsha
Titus Fortner
Simon Stewart
Boni García
Puja Jagani
Simon K
Alex Rodionov
Krishnan Mahadevan
David Burns
James Mortensen
Stay tuned for updates by following SeleniumHQ!
Happy testing!
As of version 4.6.0, all releases of Selenium (Java, JavaScript, Python, Ruby, and .Net) are shipped with Selenium Manager. Selenium Manager is a binary tool (implemented in Rust) that provides automated driver management for Selenium. Selenium Manager is still in beta, although it is becoming a relevant component of Selenium.
So far, the main feature of Selenium Manager is called automated driver management. I use the term management for this feature (and not just download) since this process is broader and implies different steps:
google-chrome --version
).~/.cache/selenium
). The next time the same driver is required, if the driver is already in the cache, it will be used from there.Driver management through Selenium Manager is opt-in for the Selenium bindings. Thus, users can continue managing their drivers manually (putting the driver in the PATH
or using system properties) or rely on a third-party manager to do it automatically. Selenium Manager only operates as a fallback: if no driver is provided, Selenium Manager will come to the rescue. Nevertheless, Selenium Manager also helps users to identify potential problems with the drivers on the PATH
.
Let’s consider an example. Imagine you manually manage your chromedriver for your Selenium tests. When you carry out this management, the stable version of Chrome is 113, so you download chromedriver 113 and put it in your PATH
. Your Selenium tests execute. Everything is fine. But the problem here is that Chrome is evergreen. This name refers to Chrome’s ability to upgrade automatically and silently to the next stable version when available. This feature is excellent for end-users but potentially dangerous for automated testing. Let’s go back to the example to discover it. Your local Chrome will eventually update to version 115. And that moment, your Selenium tests will be broken due to the incompatibility of the manually managed driver (113) and your Chrome (115). That day, your test dashboard will be red due to the following error message: “session not created: This version of ChromeDriver only supports Chrome version 113”.
This problem is the primary reason for the existence of the so-called driver managers. And as of Selenium 4.11, Selenium Manager helps to understand potential issues related to the drivers in the PATH
. When an incompatible driver release is found in the PATH
, a warning message like the following is displayed to the user:
WARN The chromedriver version (113.0.5672.63) detected in PATH at C:\my-drivers\chromedriver.exe might not be compatible with the detected chrome version (115.0.5790.110); currently, chromedriver 115.0.5790.102 is recommended for chrome 115.*, so it is advised to delete the driver in PATH and retry
The Chrome team started a very relevant initiative for the testing community in 2023: Chrome for Testing (CfT). CfT is a reduced release of Chrome primarily addressed to the testing use case.
One of the key differences between a regular Chrome release and CfT is that Chrome is evergreen, but CfT is not. This way, CfT allows pined browsers for testing. CfT releases are portable binaries (for Windows, Linux, and macOS) for different versions, including the stable, beta, dev, and canary channels. These releases can be programmatically discovered using the CfT JSON endpoints.
As of version 114, the chromedriver team has stopped publishing the chromedriver releases and metadata using their traditional chromedriver download repository. This way, and as of version 115, chromedriver releases can only be discovered programmatically using the abovementioned CfT JSON endpoints.
This change has been very relevant for the so-called driver managers. Luckily, Selenium already supports this new way of chromedriver discovery. The last version of Selenium Manager uses the CfT endpoints for chromedriver management. Therefore, if you are using Selenium Manager and Chrome, you must be updated to Selenium 4.11.0 to continue managing chromedriver automatically.
Moreover, as of Selenium 4.11.0, Selenium Manager implements automated browser management based on CfT. In other words, Selenium Manager uses the CfT endpoints to discover, download, and cache the different CfT releases, making them seamlessly available for Selenium.
Let’s suppose we want to driver Chrome with Selenium (see the doc about how to start a session with Selenium). Before the session begins, and when the driver is unavailable, Selenium Manager manages chromedriver for us. This way, all the complexity related to CfT endpoints, driver versions, etc., is transparent, and we can rely on Selenium Manager to discover, download, and cache the proper driver for us.
In addition, and as a significant novelty starting on Selenium 4.11.0, if Chrome is not installed on the local machine when executing the previous line, the current stable CfT release is discovered, downloaded, and cached (in ~/.cache/selenium/chrome
). But there is more. In addition to the stable CfT version, Selenium Manager also allows downloading of older versions of CfT (starting in version 113, which is the first version published as CfT).
To set a browser version with Selenium, we use a browser option called browserVersion. Until now, the value of this option had no effect when using the local browser since Selenium could not change what is installed in the system. But things are different with Selenium 4.11.0.
Let’s consider a simple example. Suppose we set browserVersion
to 114
using Chrome options. In this case, Selenium Manager will check if Chrome 114 is already installed. If it is, it will be used. If not, Selenium Manager will manage (i.e., discover, download, and cache) CfT 114. And in either case, the chromedriver is also managed. Finally, Selenium will start Chrome to be driven programmatically, as usual.
But there is even more. In addition to fixed browser versions (e.g., 113
, 114
, 115
, etc.), we can use the following labels for browserVersion
:
stable
: Current CfT version.beta
: Next version to stable.dev
: Version in development at this moment.canary
: Nightly build for developers.When these labels are specified, Selenium Manager first checks if a given Chrome is already installed (beta
, dev
, etc.), and when it is not detected, CfT is automatically managed.
Selenium Manager is a CLI (command line interface) tool implemented in Rust and compiled for Windows, Linux, and macOS. The Selenium Manager binaries are shipped with each Selenium release. This way, each Selenium binding language invokes Selenium Manager to carry out the automated driver and browser management previously explained.
For most users, Selenium Manager should work silently and transparently. But if you want to play with Selenium Manager or use it for your own use case (e.g., to download drivers or CfT releases), you can get the Selenium Manager binaries from the Selenium main repository.
For instance, to manage Chrome/chromedriver, the Selenium Manager command we need to invoke from the shell is the following (notice that the flag --debug
is optional, but it helps us to understand what Selenium Manager is doing):
> selenium-manager --browser chrome --debug
DEBUG Checking chromedriver in PATH
DEBUG Running command: chromedriver --version
DEBUG Output: ""
DEBUG chromedriver not found in PATH
DEBUG chrome detected at C:\Program Files\Google\Chrome\Application\chrome.exe
DEBUG Using shell command to find out chrome version
DEBUG Running command: wmic datafile where name='C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' get Version /value
DEBUG Output: "\r\r\n\r\r\nVersion=115.0.5790.110\r\r\n\r\r\n\r\r\n\r"
DEBUG Detected browser: chrome 115.0.5790.110
DEBUG Reading metadata from https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json
DEBUG Required driver: chromedriver 115.0.5790.102
DEBUG Driver URL: https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/115.0.5790.102/win64/chromedriver-win64.zip
INFO Driver path: C:\Users\boni\.cache\selenium\chromedriver\win64\115.0.5790.102\chromedriver.exe
INFO Browser path: C:\Program Files\Google\Chrome\Application\chrome.exe
In this case, the local Chrome (in Windows) is detected by Selenium Manager. Then, using its version and the CfT endpoints, the proper chromedriver version (115, in this example) is downloaded to the local cache. Finally, Selenium Manager provides two results: i) the driver path (downloaded) and ii) the browser path (local).
Let’s consider another example. Now we want to use Chrome beta. Therefore, we invoke Selenium Manager specifying that version label as follows (notice that the CfT beta is discovered, downloaded, and stored in the local cache):
> selenium-manager --browser chrome --debug --browser-version beta
DEBUG Checking chromedriver in PATH
DEBUG Running command: chromedriver --version
DEBUG Output: ""
DEBUG chromedriver not found in PATH
DEBUG Checking chrome in PATH
DEBUG Running command: where chrome
DEBUG Output: ""
DEBUG chrome not found in PATH
DEBUG chrome has not been discovered in the system
DEBUG Reading metadata from https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json
DEBUG Required browser: chrome 116.0.5845.49
DEBUG Downloading chrome 116.0.5845.49 from https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/116.0.5845.49/win64/chrome-win64.zip
DEBUG chrome 116.0.5845.49 has been downloaded at C:\Users\boni\.cache\selenium\chrome\win64\116.0.5845.49\chrome.exe
DEBUG Reading metadata from https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json
DEBUG Required driver: chromedriver 116.0.5845.49
DEBUG Driver URL: https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/116.0.5845.49/win64/chromedriver-win64.zip
INFO Driver path: C:\Users\boni\.cache\selenium\chromedriver\win64\116.0.5845.49\chromedriver.exe
INFO Browser path: C:\Users\boni\.cache\selenium\chrome\win64\116.0.5845.49\chrome.exe
If you want to get the Selenium Manager debugging information (as shown in the section before) when using the Selenium bindings languages, you can enable the logging capabilities of Selenium. Please visit the Selenium troubleshooting page for details.
You can trace the work in progress in the Selenium Manager project dashboard. The following features to be implemented in Selenium Manager will continue the automated browser management mechanism, this time for Firefox and Edge. Stay tuned!
One of the things that we knew from the very beginning of the Selenium project was that people like to code in more than one language. Some people love a bit of JS, others Ruby, and still others prefer C# or Java.
To complicate matters, there’s plenty of pieces we want to share between the language bindings you’ll be using. Examples include the “atoms” (re-usable pieces of javascript that perform common functions – such as “isDisplayed” or “getAttribute” – that we want to work the same way no matter which language you prefer to write tests in), things like our CDP support, which uses shared files that describe all the available functions we can call, and the new Selenium Manager, which is written in Rust, but we bundle with each of the language bindings.
The process of converting the source code and other artefacts (such as the atoms) together into the artefacts we distribute (such as the Selenium Server, or the language bindings) is called the “build”. There are plenty of build tools out there. If you’re a java developer, you’ve probably come across Maven or Gradle. If you’re a JS hacker, then perhaps something like npm or yarn is something you’ve used. If you’re a C developer (there are still plenty out there!) then you’re likely using make or CMake.
The problem with many build tools is that they’re focused on one language. Npm is great, but it’s a terrible choice for a Java project. Gradle is fine, but not if you’re working in Ruby.
Why is this a problem? Because in the Selenium codebase we want to support multiple different languages, and we want to be able to “stitch” them together into a single cohesive whole. For example, the Selenium jars contain a fairly large amount of JS. The Ruby gems do too.
What we want is a single build tool that can cope with lots of different languages, so we can weave our build into something where we only need that one tool.
Enter Bazel. This was a build tool originally developed by Google, but which is now Open Source and increasingly widely used. Bazel itself is relatively limited in what it can do, but it can be extended easily using “rulesets” that allow it to support everything we need, and more!
Bazel is one of a new generation of build tools, and focuses on exposing how each part of the build process relates to the other parts. You could imagine drawing a chart, with each thing we need to compile (eg. Selenium Manager, or the atoms, or one of the jars we ship) connected by lines to other parts that they depend upon. In Computer Science, that chart is called a “graph”, and because each line has a direction (“this thing depends upon that thing”) we call it a directed graph. Because we can’t depend on something that depends on itself, we can introduce a “cycle”. Bazel is a build tool designed to work with these “directed acyclic graphs”.
One nice thing about these graphs is that there are well-known ways to figure out which parts of the build can be performed in parallel. A modern computer has a CPU with many (4, 8, 16!) cores, plenty of memory, and fast SSDs: it can comfortably perform many tasks at the same time. So Bazel takes advantage of this, running as many parts of the build at the same time as it can. This makes our builds significantly faster than they used to be!
Better yet, Bazel makes us list all the things that each part of the build depends on. Not just the source code, but which versions of which tools we’re using. That makes it a lot easier for a developer new to the project to get started: they just need to clone our repo, make sure they have Bazel installed, and the build process will take care of making sure that they have everything they need (although that first build may be very slow as everything that’s needed will be downloaded from the Net). That’s not just nice for people new to the project, it’s nice for the existing developers. They no longer need to know how to install and set up toolchains that they may not be familiar with – they just run the build.
Using the “build graph”, Bazel is able to tell which pieces of code in the Selenium source code depend on which other parts. This means that although we can tell Bazel to “run all our tests” when we make a change, it’s smart enough to know that it only needs to run those tests which are actually affected by a change. You can see this in action in this video, but needless to say, this can save us a huge amount of time! We can also ask Bazel to re-run flaky tests
But there’s another advantage of describing all the things we need for a build. Since we’ve described everything we need to Bazel, and how all the pieces fit together, there’s no need to just run the build on our own machines. We’re working with EngFlow to make use of their build grid. Rather than just running a small number of things at the same time on our machines, we can run many times that on their build grid. Our builds there are incredibly fast!
So, that’s why we use Bazel on our project: it supports all the languages we want to use in a single tool, allows us to not think about how to set up our development machines, runs builds incredibly quickly, and we can make use of build grids to build things even faster.
“If it ain’t broke, don’t fix it” is a saying you may have heard, but sometimes it’s necessary to move on from our old favorites. That’s why we’re announcing that Selenium will stop supporting Java 8 on September 30, 2023. This applies for both the Java bindings and the Selenium Grid.
Selenium has long supported Java 8, but as technology evolves, so must we. One of the primary reasons for this change is that Java 8 reached the end of active support over a year ago. In addition, our default HTTP Client has not had a major release in several years, and a bug has been found that we can not fix. We have decided to move to the native Java HTTP Client, but it requires using Java 11 or greater. The sooner we make this change, the sooner we can avoid dealing with this issue.
Our new minimum version will be Java 11. September 30, 2023 is also the end of active support for Java 11. However, we want to take a cautious and conservative path forward, and not force our users to make the big jump from Java 8 to Java 17, as we understand the community might need longer to move to that version. We will revisit this topic in the future to announce the plan to support Java 17 as a minimum version.
We understand that this change may require some of our users to make adjustments, but we believe that it’s a necessary step for the continued growth of Selenium. Please take some time to check your infrastructure and ensure you’re running on Java 11 or higher. We understand that some may be hesitant or may find it difficult to make the switch, but we believe it will pay off in the long run.
Please let us know your questions, concerns, and feedback through our community chat.
Happy testing!
We’re very happy to announce the release of Selenium 4.10.0 for Java, .NET, Ruby, Python, and Javascript as well as the Grid and Internet Explorer Driver. Links to everything can be found on our downloads page.
webview2
in Edge for Java, JavaScript, and RubyOptions
classes (browser values) or Service
classes (browser driver values).Special shout-out to everyone who helped the Selenium Team get this release out!
Boris Petrov
Nikolay Borisenko
Maid
Rishav Trivedi
Alex
Michael Mintz
Vladislav Velichko
Moritz Kiefer
Valery Yatsynovich
Oboleninov Anton
Scott Stevens
Sandeep Suryaprasad
Alpatron
Tarek Oraby
robin gupta
Pallavi
Kat Rollo
Brandon Squizzato
Luis Correia
Stephan Erlank
Jordan Zimmitti
Brian Schreder
Tarek Oraby
robin gupta
Pallavi
Kat Rollo
Brandon Squizzato
Luis Correia
Stephan Erlank
Jordan Zimmitti
Brian Schreder
Thanks as well to all the Selenium Team Members who contributed to this release:
Boni García
Alex Rodionov
Tamsil Sajid Amani
Diego Molina
Titus Fortner
Simon Stewart
Krishnan Mahadevan
Sri Harsha
Puja Jagani
David Burns
James Mortensen
Stay tuned for updates by following SeleniumHQ!
Happy testing!
InvalidSelectorException
now extends from WebDriverException
Before Selenium 4.8.2 in Java and C#, when an invalid locator was used to identify an element, the resulting behavior would be inconsistent in our bindings.
For example, let’s check the following code:
ArrayList<Class<? extends Exception>> expectedExceptions = new ArrayList<>();
expectedExceptions.add(org.openqa.selenium.NoSuchElementException.class);
expectedExceptions.add(org.openqa.selenium.StaleElementReferenceException.class);
expectedExceptions.add(org.openqa.selenium.ElementNotInteractableException.class);
expectedExceptions.add(org.openqa.selenium.InvalidElementStateException.class);
return new FluentWait<>(driver)
.withTimeout(Duration.ofMillis(ELEMENT_IDENTIFICATION_TIMEOUT))
.pollingEvery(Duration.ofMillis(ELEMENT_IDENTIFICATION_POLLING_DELAY))
.ignoreAll(expectedExceptions)
.until(nestedDriver -> {
nestedDriver.findElement(By.xpath("invalid-xpath")).click;
});
The expected result before this change would be that the driver waits until the timeout expires and then throw an InvalidSelectorException
.
This doesn’t make much sense because a broken/invalid selector would never fix itself, and hence should throw immediately.
This was discussed and agreed during the TLC meeting on August 17, 2022, and implemented through the pull request 11727 and the following commit.
With the changes mentioned above, an invalid selector will throw an InvalidSelectorException
immediately.
Please note that this may have an impact on backwards compatibility if you are not expecting this exception to be thrown while handling invalid locators.
Stay tuned for updates by following SeleniumHQ!
Happy testing!
We’re very happy to announce the release of Selenium 4.9.0 for Java, .NET, Ruby, Python, and Javascript as well as the Grid and Internet Explorer Driver. Links to everything can be found on our downloads page.
InvalidSelectorException
now extends WebDriverException
instead of NoSuchElementException
.Special shout-out to everyone who helped the Selenium Team get this release out!
Ashley Trinh
Nikolay Borisenko
Ardi
Dana Sherson
Alex
Zach Attas
Ariel Juodziukynas
Henrik Skupin
Abdullah Aslam
ting
fuyou
Johnny.H
Mohab Mohie
Michael Mintz
Michael Render
Tobias Smolka
Étienne Barrié
James Hilliard
Mark Mayo
Thanks as well to all the Selenium Team Members who contributed to this release:
Alex Rodionov
Boni García
Titus Fortner
Diego Molina
Tamsil Sajid Amani
Sri Harsha
Simon Stewart
Krishnan Mahadevan
David Burns
Simon K
Puja Jagani
Stay tuned for updates by following SeleniumHQ!
Happy testing!
This year is special, thanks to the decision to host an in-person conference after a long hiatus and several years of virtual-only events. We’ve gone out of our way to reflect this feeling at the conference. We have engrossing keynotes, well-researched talks, hands-on pre-conference workshops, hallway tracks, and whatnot!
We have Diego Molina kicking things off with ‘Selenium: State of the Union’ where he will talk about all things Selenium, including the project, the code, and the community. Think of it as a journey through the times with Selenium. A must-attend without any shred of doubt!
Next up is Erika Chestnut’s ‘Bigger Than The Box’ where she will focus on the idea of quality and whether it has been restricted to only a single step in the delivery process. It is indeed a dialogue that needs to happen given that our lives revolve around quality.
On day 2, we have first-time SeleniumConf keynote speaker Mark Winteringham from the Ministry of Testing talking about ‘What Exactly Do You Do in Test Automation?’ Is it just about coding and frameworks or is there more to it? How should a test automation practitioner think about their role? Think of this as learning from the ground up or in some cases, back to the basics!
We’ve cast our net far and wide this time around.
Just as a highlight, across the two days, we will cover a diverse range of topics from crawlers, identifying code smells, blended testing, component testing, quality gates, quality metrics to track, testing with real robots, and managing the test data nightmare, among others. Quite a list, huh? Trust me, this is just a sneak peek. You can check out the entire list here.
Also, we’ve got a session on how testing with Selenium is solving unemployment in Africa.
The cherry on the cake is the Q&A with the Selenium Committer’s Panel where you’ll get to pick the brains of the very people who’ve built Selenium.
In a way, we’ve truly tried our best to touch upon the technology, people, and process aspects of testing. We’d love to have you over to catch these experts in action!
Testing is all about exploring. How about exploring and diving into something new?
We’ve got community leaders doing deep dives into Selenium, Appium 2.0, how to become a committer, state model-based testing, and driving observability with Selenium Grid.
We truly believe that nothing beats hearing it from the horse’s mouth.
While there are some amazing keynotes, well-researched talks, and structured workshops, we really think the biggest takeaway for any attendee is the people they’ll get to meet. Selenium has been a great example of how the community can come together to build something that is greater than the sum of its parts. A conference like this brings together folks from across the world, with different levels of experience, and puts them under a single roof.
What can be more beautiful than getting to interact with the very community that has built and grown Selenium?
What are you waiting for? Register now! We can’t wait to welcome you to Chicago!
Headless is an execution mode for Firefox and Chromium based browsers. It allows users to run automated scripts in headless mode, meaning that the browser window wouldn’t be visible. In most of Selenium’s bindings there is a convenience method to set this execution mode while setting the browser options. However, Selenium 4.8.0 will be deprecated this method and now users need to set it through arguments when setting the browser options.
Chromium based browsers have now two different headless modes (the original one, and one with more
capabilities added in 2022). When a user sets headless to true
via the convenience method in Selenium,
it is using the initial method provided by Chromium based browsers.
By deprecating the convenience method (and removing it in Selenium 4.10.0), users will be in full control to choose which headless mode they want to use.
The traditional --headless
, and since version 96, Chrome has a new headless mode that allows users to
get the full browser functionality (even run extensions). Between versions 96 to 108 it was
--headless=chrome
, after version 109 --headless=new
.
Using --headless=new
should bring a better experience when using headless with Selenium.
Thanks to Michael Mintz for the detailed explanation!
Check more details about the new headleass mode at the official Chrome blog.
In short, users can add the headless mode they want to use through arguments in browser options.
ChromeOptions options = new ChromeOptions();
options.setHeadless(true);
WebDriver driver = new ChromeDriver(options);
driver.get("https://selenium.dev");
driver.quit();
let driver = await env
.builder()
.setChromeOptions(new chrome.Options().headless())
.build();
await driver.get('https://selenium.dev');
await driver.quit();
// C# did not have a convenience method
options = Selenium::WebDriver::Chrome::Options.new
options.headless!
driver = Selenium::WebDriver.for :chrome, options: options
driver.get('https://selenium.dev')
driver.quit
options = ChromeOptions()
options.headless = True
driver = webdriver.Chrome(options=options)
driver.get('http://selenium.dev')
driver.quit()
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
WebDriver driver = new ChromeDriver(options);
driver.get("https://selenium.dev");
driver.quit();
let driver = await env
.builder()
.setChromeOptions(options.addArguments('--headless=new'))
.build();
await driver.get('https://selenium.dev');
await driver.quit();
var options = new ChromeOptions();
options.AddArgument("--headless=new");
var driver = new ChromeDriver(options);
driver.Navigate().GoToUrl("https://selenium.dev");
driver.Quit();
options = Selenium::WebDriver::Options.chrome(args: ['--headless=new'])
driver = Selenium::WebDriver.for :chrome, options: options
driver.get('https://selenium.dev')
driver.quit
options = ChromeOptions()
options.add_argument("--headless=new")
driver = webdriver.Chrome(options=options)
driver.get('http://selenium.dev')
driver.quit()
If you have any questions or comments, please reach out through any of all the available options shown at our support page.
Stay tuned for updates by following SeleniumHQ!
Happy testing!
We’re very happy to announce the release of Selenium 4.8.0 for Java, .NET, Ruby, Python, and Javascript as well as the Grid and Internet Explorer Driver. Links to everything can be found on our downloads page.
Special shout-out to everyone who helped the Selenium Team get this release out!
Nikolay Borisenko
Kian Eliasi
James Hilliard
Potapov Dmitriy
Johnson Sun
George Adams
Jon Dufresne
Valery Yatsynovich
Thanks as well to all the Selenium Team Members who contributed to this release:
David Burns
Alex Rodionov
Titus Fortner
Diego Molina
Puja Jagani
Krishnan Mahadevan
Sri Harsha
Boni García
Simon K
Simon Stewart
Tamsil Sajid Amani
It was an amazing year here at the Selenium project, and we wanted to remind you of some of the great things we accomplished.
In terms of releases, we continued to build on top of Selenium 4 which was launched in October 2021. This year we published v4.2, v4.3, v4.4, v4.5, v4.6, and v4.7. These releases included improvements, bug fixes, removal of deprecated functionality, improved error handling, updates of the underlying libraries, support for the latest Chrome DevTools versions to keep you in sync with new browser releases, but also new features.
We introduced the first (beta) version of the embedded Selenium Manager. The purpose of this feature is to help you manage your driver binaries without having to manually update them yourself each time a new version is released. We also introduced observability in the Docker-Selenium images. Another major new feature is native support for scrolling in the Actions API. But these are only some of the highlights of what we released. To get the details for each language we support, you can check out their corresponding Changelog pages: Java, Python, Ruby, Javascript, DotNet.
In terms of events and gatherings, in July our Selenium India Conference took place, this time online. It kicked off with an 8 talk pre-conference event, namely Selenium Lite. We then had a full day of workshops, followed by 2 days of conference. We had over 50 speakers and over 800 participants from around the world. The talks focused on Selenium, the Selenium ecosystem, automation, methodologies and best practices. In case you missed some of these talks, you can still watch them here.
We also held 2 test automation summits: one in San Francisco and one in Berlin. During these workshops the participants, together with some of the maintainers of frameworks from the Selenium ecosystem, built their Selenium based projects, added tests, new features and fixed bugs. During the first summit the participants focused on the BiDi protocol, while during the second one the focus was on Appium and mobile automation.
We are kicking off next year with a few surprises. The Selenium Conference in Chicago just announced the Speaker Lineup. Stay tuned for further details!
Many thanks to everyone who has contributed to the Selenium project for all their hard work this year!
And special thanks to all of you who are using, following and supporting the Selenium project.
From everyone here at SeleniumHQ, may you have the best holidays and an amazing new year. See you in 2023!
As many of you know, the Selenium Conference returns to an in-person event next March 28-30, 2023 in Chicago, IL. The Program Chairs & Committee, as well as the Extended Program Review Committee, have been hard at work putting together an outstanding lineup of speakers and workshops, and we’re close to releasing the full agenda and a completely re-branded conference website - stay tuned! In the meantime, we wanted you to be among the first to know who will be presenting, announce a new, additional pre-conference workshop, and provide you with some important updates. Here we go!
There will be four plenary keynote presentations across the 2-day conference. Selenium Core Committer Diego Molina will open the conference on Wednesday with the “Selenium: State of the Union” presentation, followed by Quality & Leadership Coach Erika Chestnut presenting “Bigger Than The Box”, where she shares how she has crossed the aisles to elevate and expand the role quality in the organizations that she has worked for. Day 2 kicks off with Mark Winteringham, Ministry of Testing OpsBoss, presenting “What Exactly Do You Do In Test Automation”. The final keynote session will be a Q&A with the Selenium Committers panel.
Following the opening keynote presentations, there will be two separate track sessions running in parallel. Here are the confirmed speakers to date and the presentations they will be giving:
We’re pleased to announce a new addition to the optional pre-conference workshop day, State Model-Based Testing Using Selenium, led by Ru Cindrea, Managing Partner and Senior Test Consultant, Altom Consulting & Alex Rotaru, Co-owner, Altom Consulting. If you haven’t yet heard of State Model-Based Testing (SMBT) is a testing technique that allows testers to visualize their applications and to generate and automate test flows by using different models of the application under test, thus obtaining a large number of test scenarios. When certain paths of the application are changed, the benefit of using SMBT is that you will only have to modify the states and transitions that apply to that change.
This workshop rounds out the core pre-conference workshop offerings, which include a Selenium Deep Dive session led by Selenium Project Core Committer, Titus Fortner; Driving Observability with Selenium Grid 4, led by Manoj Kumar, VP, Developer Relations at LambdaTest and Selenium Project Leadership Committee member, and Advanced Appium 2.0, with Srini Sekar & Sai Krishna, Lead Consultants at Thoughtworks and long-time Appium workshop instructors.
Workshops are one of the most popular offerings at any SeleniumConf and because class sizes are limited they invariably sell-out. Early Bird ticket sales have closed, but you can still find openings for any of these awesome day-long sessions. Register today and make sure you get a seat at the Conference + Workshop session of your choice.
If you’re a long-time follower of past Selenium Conferences, or just happened to attend the July, 2022 virtual SeleniumConf, you may be familiar with the long-standing workshop offering “Fix a Bug, Become a Committer”. This workshop is a bit different in that the goal is to both enhance your own Selenium experience while offering the ability to contribute back to the project. With this, it’s not a learning session, per se, but more of a doing session, and we thought we’d take a different approach this time and make it available at no-charge (other than buying a conference ticket) to a limited number of applicants. If you are familiar with Selenium and want to extend your conference experience an extra day we encourage you to apply. Scholarship applicants (more below) are also welcome to apply.
The mission of the Selenium project is to educate the QA and developer communities about Selenium, the importance of quality assurance, and automated testing in general. Both the Selenium project and the SeleniumConf organizers very much want everyone to be able to attend the conference, but we know that not everyone’s personal or financial circumstances make this possible - so, we’re setting aside a number of free tickets, and covering travel expenses, as part of our SeleniumConf Chicago 2023 scholarship program.
The program aims to support individuals from underrepresented groups in tech and those facing economic or social hardship so they have access to SeConf content and networking opportunities. If you’re an aspiring software professional looking to use Selenium, or a current one without access to the funds to buy your ticket, you should apply. We will award tickets to people who can show that the knowledge gained will be useful for their ongoing career. The application form will be posted in January, 2023.
You’ve now seen the keynotes, the current roster of speakers, and the awesome hands-on workshop descriptions, but you still need more to convince your manager? Download this “Convince Your Boss” email template and tailor it to your specific rationale using the details you’ve gleaned from this post. We’d really like to see you next March in Chicago - so register here!
We’re very happy to announce the release of Selenium 4.7.0 for Java, .NET, and Javascript as well as the Grid and Internet Explorer Driver; for Ruby use 4.7.1, and Python 4.7.2. Links to everything can be found on our downloads page.
Special shout-out to everyone who helped the Selenium Team get this release out!
Christian Clauss
Dor Blayzer
Fenil Mehta
Jared Webber
Michael Mintz
Nikolay Borisenko
Tamsil Sajid Amani
Thanks as well to all the Selenium Team Members who contributed to this release:
David Burns
Boni García
Diego Molina
Sri Harsha
Alex Rodionov
Puja Jagani
Simon Stewart
Simon K
Titus Fortner
Over the last decade, a large ecosystem of Open Source projects has sprouted up around Selenium. Selenium is often used for automating web applications for testing purposes, but it does not include a testing framework. Nowadays, Selenium Ecosystem initiatives try to give popularity to popular open-source test automation frameworks maintained by people outside of the core Selenium maintainers. One of these frameworks is BELLATRIX, invented by Anton Angelov. It has two versions - C# and Java. A testing framework is an abstraction in which common code provides generic functionality (which can be selectively overridden) for testing different aspects of our applications- UI, API, security, performance, and many others.
The first version of BELLATRIX appeared on 26 December 2017. It was available only for C# initially, but written on the new back then .NET Core, allowing the framework to be used on all major operating systems (cross-platform). One huge advantage of BELLATRIX is its cross-technology readiness. It allows you to write tests for different technologies such as Web, Mobile, Desktop, and API. In BELLATRIX, we strive for the API for all modules to be as identical as possible.
The usage is simple. We suggest cloning BELLATRIX as a GIT sub-module. Then, any customizations, tests, and project-specific plug-ins should be placed in a project outside the BELLATRIX cloned repository. This way, you can quickly update to the latest version.
BELLATRIX official website, download and releases info
BELLATRIX official C# GitHub Page
BELLATRIX official Java GitHub Page
Let’s investigate how easy it is to create your first test with BELLATRIX in 15 minutes. The sample will showcase how to create a very basic test login into a website:
[TestClass]
public class LoginTestsMSTest : MSTest.WebTest
{
public override void TestInit()
{
App.Navigation.Navigate("http://demos.bellatrix.solutions/my-account/");
}
[TestMethod]
public void SuccessfullyLoginToMyAccount()
{
var userNameField = App.Components.CreateById<TextField>("username");
var passwordField = App.Components.CreateById<Password>("password");
var loginButton = App.Components.CreateByXpath<Button>("//button[@name='login']");
userNameField.SetText("info@yourverybusywebsite.com");
passwordField.SetPassword("yourverysecretp4ssw0rd$");
loginButton.Click();
var myAccountContentDiv = App.Components.CreateByClass<Div>("woocommerce-MyAccount-content");
myAccountContentDiv.ValidateInnerTextContains("Hello John");
var logoutLink = App.Components.CreateByInnerTextContaining<Anchor>("Log out");
logoutLink.ValidateIsVisible();
logoutLink.Click();
}
}
All available services are available through the main App class. The Components property provides various Create methods for finding elements. They are generic, so you need to mention the type of the searched element. We have different elements because, for each of them, BELLATRIX offers various additional methods and assertions on top of native WebDriver methods. The sample code uses MSTest as the default test framework, but by changing the attributes, it will also work out of the box for NUnit. Of course, you need to change the base class namespace too.
Let’s quickly list some of the essential things the framework brings to the table:
Every aspect of the framework can be controlled via a rich JSON configuration designed to work for many test environments. Web Project Configuration.
One of the hardest things to develop is to allow these generic frameworks to be extendable and customizable. Knowing how essential customization is, we utilize different ways to achieve it. The major one is about writing your own plug-ins.
One of the biggest problems in test automation is handling timeouts and performing actions on elements that may not be on the page right now. BELLATRIX hides the complexity of searching and waiting for elements. Furthermore, when you perform an action or assertion against an element, we guarantee that once returned, it will be present.
A significant part of your tests are the assertions - checking whether some conditions are met. To handle such scenarios, we created elements Validate methods. They internally handle the whole complexity of waiting for some condition to happen.
updateCart.ValidateIsDisabled();
totalSpan.ValidateInnerTextIs("120.00€", timeout: 30, sleepInterval: 2);
messageAlert.ValidateIsNotVisible();
BELLATRIX provides API that makes handling HTML tables and grids much easier HTML tables and grids.Here is an example for asserting grid cells:
TestGrid.ForEachCell(cell => cell.AssertFontSize("14px"));
TestGrid.GetCell("Firstname", 1).ValidateInnerTextIs("Mary");
TestGrid.GetCell(0, 1).ValidateInnerTextIs("John");
TestGrid.GetCell<Employee>(cell => cell.PersonalEmail, 1).ValidateInnerTextIs("mary@hotmail.com");
There is much more complex stuff that you can do with both components so check the official documentation.
Seamlessly integrate the framework with your existing tools and processes. Execute tests in the clouds, distribute and publish test results in reporting solutions. Maybe the most significant differentiators of the framework are its many integrations with popular tools such as Jira/qTest/Allure/ReportPortal and clouds such as AWS, Microsoft Azure, + many more. All these integrations leverage BELLATRIX plug-in architecture. For example, we have plug-ins for automatically generating/updating test cases based on our automated tests in qTest and AzureDevops or similarly creating automatic bug reports with steps to reproduce in Jira or Azure.
Dynamic test cases are a unique feature in BELLATRIX, where the framework automatically generates test cases in a popular test case management system based on your automated tests. It will populate the title, description, and other necessary properties automatically. Moreover, it will generate human-readable steps and expected results. The most significant benefit is that it will keep up to date with your auto-generated test cases over time, no matter what you change in your tests. It is an excellent functionality which allows the non-technical people of your company to see what your tests are doing.
Azure Computer Vision is a service that can be used to extract printed and handwritten text from images and documents with mixed languages and writing styles. In contrast, Azure Form Recognizer is an AI-powered document extraction service that understands your document. You are not limited to PDFs only. You can use the same feature for extracting text from complex images. BELLATRIX comes with similar functionality based on the AWS cloud.
BELLATRIX offers a few utilities for email testing. There are a few scenarios where we need such integration. The first one is related to creating unique email inboxes and using them to submit various online forms. Later, we can read the emails via the services and check the content of the emails. It might be enough to verify the content via regular C#, or in some cases, we might need to interact with the email content in the browser.
There are tons of other integrations that we use on a daily basis in many big enterprise projects, such as cloud secrets management for securely storing credentials and other secrets. All BELLATRIX Integrations
Using BELLATRIX in your projects might save months/years of effort even if you have the required programming knowledge. This way, you can quickly focus on writing automated tests for your project. Usually, there are 4-6 major releases each year, including all bug fixes and new features. Check our release notes history. The framework is fully covered with over 4000 automated tests and offers rich documentation. We make sure to merge the new feature branches only when we are sure that everything is working. If some issue emerges after a major release, it is quickly fixed within a few days.
For feature requests or bug reports, you can submit them to our GitHub repositories. If you believe that the functionality you developed can be added to the CORE framework or you have a bug fix, please submit a PR so we can discuss it and potentially merge it. For anything else, you can reach us via our contact us form.
Most people’s first experience with Selenium ends up with an error message like this one:
java.lang.IllegalStateException: The path to the driver executable must be set by the webdriver.chrome.driver
system property; for more information, see https://chromedriver.chromium.org/. The latest version can be
downloaded from https://chromedriver.chromium.org/downloads
Then they have to search the web for instructions on what to do with the drivers they download.
The Selenium project wants to improve the user experience, and one of the first steps is to help all users to simplify how they set up their environment. Configuring browser drivers has been for many years a task which users need to perform in order to have a working environment to run Selenium.
Setting up a browser driver once is not that complicated, but as browser release cycles got shorter, and now we have a new Chrome/Firefox/Edge version every 4-6 weeks, the task of keeping the browser driver in sync with the browser version is not that easy anymore.
Selenium Manager is a new tool that helps to get a working environment to run Selenium out of the box. Beta 1
of Selenium Manager will configure the browser drivers for Chrome, Firefox, and Edge if they are not present
on the PATH
.
To run a Selenium test with Selenium 4.6, you only need to have Chrome, Firefox, or Edge installed. If you already have browser drivers installed, this feature will be ignored. If you’d like to help us test it, though, delete your drivers or remove your third party driver manager and things should still “just work.” If they don’t, please file a bug report.
Future releases of Selenium Manager will eventually even download browsers if necessary.
Selenium Manager is not a completely new solution. Over the years, several third-party projects in the Selenium ecosystem emerged. Such as: WebDriverManager for Java, webdriver-manager for Python, webdrivers for Ruby, and WebDriverManager.Net for C#.
All these projects served as an inspiration and as a clear sign that the community needed this feature to be built-in Selenium. In addition, a survey done on January 2021 showed that most Selenium users want to get rid of the driver management problem. Plus, the fact that the driver installation page is by far the most visited one in the Selenium documentation.
Selenium Manager is a CLI (Command-Line Interface) tool developed in Rust to allow cross platform execution.
On its beta 1 version, Selenium Manager is invoked transparently by the Selenium bindings when no browser
driver is detected on the PATH
or no third party driver manager is being used.
You can also use Selenium Manager without the Selenium bindings. While we plan to do formal releases in the future, for now, the binaries can be found directly on the Selenium repository. Check the different parameters and options by running the following command:
$ ./selenium-manager --help
A quick example showing how ChromeDriver
gets configured can be seen below:
$ ./selenium-manager --browser chrome
INFO /home/boni/.cache/selenium/chromedriver/linux64/106.0.5249.61/chromedriver
If you maintain a WebDriver based project and would like to use Selenium Manager as well, join us in our community channels and we would be happy to help. Also, if you are interested in contributing, for detailed instructions and information check the project’s README.
Selenium Manager is still under development, features will be added and bugs fixed along with each release. However, you as a member of the Selenium community are key part on the future success of this new tool. Please report ideas or bugs through our issue tracker and join the conversation through our community channels. Looking forward to your feedback!
Happy testing!
We’re very happy to announce the release of Selenium 4.6.0 for Java, .NET, Python, Ruby, and JavaScript bindings as well as the Grid and Internet Explorer Driver. Links to everything can be found on our downloads page.
Huge thanks to all the contributors who made this version possible:
Nick Crews
Simon K
Chris Stringer
Kazuki Higashiguchi
Brandon Walderman
Václav Votípka
Konstantin Kotenko
Vinothkumar Ranganathan
Hyesung Lee
Titus Fortner
Boni García
Sri Harsha
Muhammad Hammad
Nikolay Borisenko
Alex Rodionov
Puja Jagani
Tamsil Sajid Amani
Yevgeniy Shunevych
Krishnan Mahadevan
We’re very happy to announce the release of Selenium 4.5.0 for Java, .NET, Python, Ruby, and JavaScript bindings as well as the Grid and Internet Explorer Driver. Links to everything can be found on our Downloads Page.
Huge thanks to all the external contributors who made this version possible:
Guille
Austin Michael Wilkins
Andrei Solntsev
Bartek Florczak
Vikas Goel
Kazuki Higashiguchi
Kazuaki Matsuo
Michael Mintz
Nikolay Borisenko
Kim Hyeonseok
Potapov Dmitriy
Shishu Raj Pandey
Tamsil Sajid Amani
Tony Narlock
Henrik Skupin
Selenium uses an HTTP client and associated WebSocket client for multiple purposes
Currently, Selenium uses AsyncHttpClient. AsyncHttpClient is an open-source library built on top of Netty. It allows the execution of HTTP requests and responses asynchronously. Additionally it also provides WebSocket support. Hence it is a good fit.
While AsyncHttpClient provides the required functionality, the open-source project is not been actively maintained since June 2021. It coincides with the fact that Java 11+ provides a built-in HTTP and WebSocket client. Selenium can utilize it to replace AsyncHttpClient.
Currently, Selenium Java supports Java 8. Selenium has plans to upgrade the minimum version supported to Java 11. However, it is a sizeable effort. Aligning it with major releases and accompanied announcements is crucial to ensure the user experience is intact.
The Selenium server runs great on Java 11+ already, so while we plan to make that the minimum version in a future release, for now we plan to introduce optional components that can take advantage of modern Java releases.
So as a first step towards this move, the Java 11+ HTTP client from Selenium 4.5.0 and above.
Java 11+ HTTP client sits in its own artifact. It can be imported into projects that use Java 11+.
Add the follow dependencies to your pom.xml
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>4.5.0</version>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-http-jdk-client</artifactId>
<version>4.5.0</version>
</dependency>
NOTE: In the dependencies above version 4.5.0
is shown, however we recommend you to check the
downloads page to use the latest version released. Make sure the versions used are
matching.
Set the system property to indicate that Java 11+ Http client needs to be used. By default, it uses the AsyncHttpClient.
System.setProperty("webdriver.http.factory", "jdk-http-client");
You are all set up to leverage the newly supported client. The user-experience remains the unchanged. Everything else works as expected.
To do that, you will need to download the selenium-http-jdk-client
jar file and
use the --ext
flag to make it available in the Grid jar’s classpath.
The jar file can be downloaded directly from repo1.maven.org and then start the Grid in the following way:
java -Dwebdriver.http.factory=jdk-http-client -jar selenium-server-4.5.0.jar -—ext selenium-http-jdk-client-4.5.0.jar standalone
An alternative to downloading the selenium-http-jdk-client
jar file is to use Coursier.
java -Dwebdriver.http.factory=jdk-http-client -jar selenium-server-4.5.0.jar —-ext $(coursier fetch -p org.seleniumhq.selenium:selenium-http-jdk-client:4.5.0) standalone
If you are using the Hub/Node(s) mode or the Distributed mode, setting the -Dwebdriver.http.factory=jdk-http-client
and —-ext
flags
needs to be done for each one of the components.
NOTE: In the dependencies above version 4.5.0
is shown, however we recommend you to check the
downloads page to use the latest version released. Make sure the versions used are
matching.
Huge thanks to Simon Stewart (@shs96c) for making this possible with his contribution!
The Docker Selenium browser Beta and Dev channel releases are now regularly published to Docker Hub and updated every two days. This enables testers and developers to test their applications on pre-release versions of Google Chrome, Mozilla Firefox, and Microsoft Edge before their official releases, using container tools, such as Docker. This empowers teams to stay ahead of the curve and catch potential showstoppers in their CI environment before those issues have an impact on their users.
Here’s some background on release channels: Google, Mozilla, and Microsoft all maintain different “channels” for their respective browser releases. Most end users use the “Stable” channel. The Stable channel releases have passed rigorous testing, and these versions are considered “production-ready”. Up until now, this was the only option for a tester or developer when using Docker Selenium. Today, we’re pleased to announce teams can also test on versions of these browsers yet to be released to the general population. These are the Beta and Dev channels.
For clarity, here is Google’s description of these 3 channels from their “Chrome Release Channels” page:
Stable channel: This channel has gotten the full testing and blessing of the Chrome test team, and is the best bet to avoid crashes and other issues. It’s updated roughly every two-three weeks for minor releases, and every 6 weeks for major releases.
Beta channel: If you are interested in seeing what’s next, with minimal risk, Beta channel is the place to be. It’s updated every week roughly, with major updates coming every six weeks, more than a month before the Stable channel will get them.
Dev channel: If you want to see what’s happening quickly, then you want the Dev channel. The Dev channel gets updated once or twice weekly, and it shows what we’re working on right now. There’s no lag between major versions, whatever code we’ve got, you will get. While this build does get tested, it is still subject to bugs, as we want people to see what’s new as soon as possible.
To use these new Docker Selenium container images in Standalone mode, run the following commands:
Chrome Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:beta
Chrome Dev:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:dev
Firefox Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:beta
Firefox Dev:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:dev
Edge Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:beta
Edge Dev:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:dev
To run these container images in a Selenium Grid, we’ll use docker-compose. For instance, this example shows how to run a Selenium Grid with Chrome, Firefox, and Edge on the Beta channel:
docker-compose-v3-beta-channel.yml:
# To execute this docker-compose yml file use `docker-compose -f docker-compose-v3-beta-channel.yml up`
# Add the `-d` flag at the end for detached execution
# To stop the execution, hit Ctrl+C, and then `docker-compose -f docker-compose-v3-beta-channel.yml down`
version: "3"
services:
chrome:
image: selenium/node-chrome:beta
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
edge:
image: selenium/node-edge:beta
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
firefox:
image: selenium/node-firefox:beta
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium-hub:
image: selenium/hub:latest
container_name: selenium-hub
ports:
- "4442:4442"
- "4443:4443"
- "4444:4444"
To run on the more cutting edge – and hence potentially more buggy – Dev channel, simply replace the “beta” tags with “dev”.
These Beta and Dev images represent pre-release browsers and WebDrivers, and they’re not guaranteed to be 100% stable. Should you run into any issues with these images, support from the Selenium community is limited and is dependent on the browser vendors. However, if you believe the issue is related to Selenium, please contact us in the various support channels.
If you have any experience with Selenium Grid and Kubernetes you will probably run into an issue with scaling. Kubernetes (K8S) works wonders for scaling up and down applications based on their CPU and Memory usage, but it is not so straightforward when it comes down to applications like Selenium Grid.
The issue is described quite well in this blog post. But in short, the Horizontal Pod AutoScaler (HPA) that is built into Kubernetes checks (by default) for resource consumption to determine if a deployment needs to be scaled up or down. This becomes an issue for Selenium Grid for a couple reasons:
KEDA is a free and open-source Kubernetes event-driven autoscaling solution that extends the feature set of K8S’ HPA. This is done via plugins written by the community that feed KEDA’s metrics server with the information it needs to scale specific deployments up and down.
Specifically for Selenium Grid, we have a plugin that will tie into our grid to get the information it needs. Example of the used trigger:
triggers:
- type: selenium-grid
metadata:
url: 'http://selenium-grid-url-or-ip:4444/graphql'
browserName: 'chrome'
All of this gets saved as a Scaled-Object like so:
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: selenium-chrome-scaledobject
namespace: <namespace of your browser pods>
labels:
deploymentName: selenium-chrome-node-deployment
spec:
minReplicaCount: 0
maxReplicaCount: 80
scaleTargetRef:
name: selenium-chrome-node-deployment
triggers:
- type: selenium-grid
metadata:
url: 'https://selenium-grid-url-or-ip:4444/graphql'
browserName: 'chrome'
As an added bonus KEDA allows us to scale our deployments down to 0 when there is no use, something the normal out-of-the-box HPA does not allow.
Check more details at the documentation for Scaled-Object in KEDA.
A full example of how to implement this is further down in the article but KEDA solves one of our two issues. Now we can properly scale up and down based on the actual load on the Selenium Grid. Unfortunately scaling down still results in the likely possibility that a pod is still running a test and is told to terminate before it can finish.
To combat this we are going to use a combination of K8s PreStop and Selenium Grid’s Drain functionality.
PreStop
allows us to set a command or chain of commands that is run to completion before the container is told to stop.Together these look like so in our browser pod yaml:
spec:
template:
spec:
terminationGracePeriodSeconds: 3600
...
...
containers:
lifecycle:
preStop:
exec:
command: ["/bin/sh", "-c", "curl --request POST 'localhost:5555/se/grid/node/drain' --header 'X-REGISTRATION-SECRET;'; tail --pid=$(pgrep -f '[n]ode --bind-host false --config /opt/selenium/config.toml') -f /dev/null; sleep 30s"]
terminationGracePeriodSeconds
is set to however long you wish to give your
pods to gracefully terminate before being forced. In this case I give the pods
60 minutes to finish their test when asked to terminate. If you are also scaling
your cluster nodes as a part of this you may need to increase the termination
grace period for your cluster nodes as well.PreStop
command is ran first.localhost
of our pod to tell it to drain. The pod will no
longer accept new session requests and will finish its current test. More
information on this can be found in the Selenium Grid documentation.And with that our application can now safely scale down our selenium browser deployments!
kubectl apply -f https://github.com/kedacore/keda/releases/download/<Version_Number_Here>/keda-<Version_Number_Here>.yaml
As described earlier your scaled object will look like so:
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: selenium-chrome-scaledobject
namespace: <namespace of your browser pods>
labels:
deploymentName: selenium-chrome-node-deployment
spec:
minReplicaCount: 0
maxReplicaCount: 80
scaleTargetRef:
name: selenium-chrome-node-deployment
triggers:
- type: selenium-grid
metadata:
url: 'https://selenium-grid-url-or-ip:4444/graphql'
browserName: 'chrome'
You will need one of these for every browser you wish to scale.
Things to edit:
namespace
should be the namespace that your selenium browser pods exist indeploymentName
are the name of your browser deploymentname
(within spec) is also the name of your browser deploymenturl
is the url of your selenium gridbrowserName
is the name of the browser you are usingminReplicaCount
and maxReplicaCount
are the min and maximum pod count you want to haveIf you plan to scale with Edge you will need at least version 2.8.0
of KEDA and will
need to include sessionBrowserName
as well in the trigger metadata:
triggers:
- type: selenium-grid
metadata:
url: 'https://selenium-grid-url-or-ip:4444/graphql'
browserName: 'MicrosoftEdge'
sessionBrowserName: 'msedge'
This is due to a name change between the Edge sessions in the queue and the active sessions and is addressed through this pull request.
Once you have that ready just save it as a yaml file and apply with:
kubectl apply -f ./<scaled-object-file-name>.yaml --namespace=<browser_namespace>
terminationGracePeriodSeconds
of your deployment to whatever the maximum
time you wish to give the pods in order to terminate gracefully. Again you may need to
also increase the grace period for your nodepool as well which will vary depending on
your K8s provider.PreStop
command to the container lifecycle spec:spec:
template:
spec:
terminationGracePeriodSeconds: 3600
...
...
containers:
lifecycle:
preStop:
exec:
command: ["/bin/sh", "-c", "curl --request POST 'localhost:5555/se/grid/node/drain' --header 'X-REGISTRATION-SECRET;'; tail --pid=$(pgrep -f '[n]ode --bind-host false --config /opt/selenium/config.toml') -f /dev/null; sleep 30s"]
That is it, your Selenium Grid pods should now scale up and down properly without any lost sessions!
We’re very happy to announce the release of Selenium 4.4.0. We’re shipping this for Java, .Net, Python, Ruby, and JavaScript, so if you’re using any of those languages, go and grab it from your package manager of choice!
Some of the main highlights are:
w3c: false
is set in ChromeOptions
Check the complete changelog and download the artifacts at the Selenium 4.4.0 release in GitHub or directly from the Selenium site.
Huge thanks to all the contributors who made this version possible:
praveendvd
Bogdan Condurache
Andrei Solntsev
Alex Rodionov
Boni García
Ravi Sawlani
jsfehler
elgatov
Valery Yatsynovich
Yusuke Noda
Kevin Dew
Brandon Walderman
Nikolay Borisenko
Robert Fletcher
Simon K
Yevgeniy Shunevych
Tamsil Sajid Amani
Tony Narlock
Sri Harsha
Have you ever wanted to contribute to an open source testing project, but couldn’t figure out where to start?
If so, fill out this form
to apply for an invitation to join the Open Source Test Automation Summit on August 26 in Berlin,
sponsored by Selenium and hosted by Sauce Labs.
You can review the list of available projects below and select the one that you’d like to contribute to. We’ll be in touch soon if you
are selected to join us.
Update 7/22/2022: Application deadline is July 28! We’ll contact everyone by Friday, July 29.
This will not be your typical workshop. This will be a working session with one or more maintainers of a given project to show you exactly what you need to know to contribute to that project. Selected participants will be required to bring a laptop capable of executing Selenium tests, including a working dev environment for the applicable programming language.
This is a new idea we’re trying out, so space is very limited. If there is sufficient demand we will consider doing more events like this in the future.
At the end of the session you will be able to:
Start | End | Activity |
---|---|---|
0900 | 0930 | Breakfast |
0930 | 1000 | Talk: “State of WebDriver Ecosystem” |
1000 | 1100 | Lightning talks about participating projects |
1100 | 1200 | Split into working groups and walk through projects |
1200 | 1300 | Lunch |
1300 | 1630 | Continue with working sessions |
1630 | 1700 | Wrap up |
1700 | Happy hour |
The following maintainers are will be present to assist you in working on their project:
Update 7/20/2022: Ronald Brill, maintainer of HTMLUnit Driver will now be joining us!
Update 7/25/2022: Yevgeniy Shunevych, maintainer of Atata will now be joining us!
Update 7/26/2022: Simon Stewart, creator of WebDriver, will now be joining us!
Do you maintain an open source project in the WebDriver ecosystem?
Have you written a test framework that uses Selenium that is (or you want to make) open source?
Please fill out this form
(provide additional relevant details in the comments), and we will be in touch about future events.
The Selenium team prides itself on how seriously it takes backwards compatibility. A lot of care has gone into the Java bindings, especially, to ensure very few breaking changes over the years. There is Selenium code written 15 years ago that can still run with Selenium 4 libraries! Providing this exceptional amount of support comes with a large maintenance burden, though, and we need to be able to properly meet the needs of the vast majority of our userbase.
TL/DR:
By far the biggest challenge in the past seven years of Selenium development has been transitioning the underlying implementation from the legacy JSON Wire Protocol to the new standardized W3C WebDriver Protocol. Because the WebDriver specification was being actively developed at the time, Selenium 3 supported both protocols simultaneously. We implemented “handshake” code to determine which protocol to use. When starting a session, Selenium would package the provided capabilities in both legacy and W3C formats, send them to the driver/server, and use whichever protocol was returned. This worked well for the most part. For many users, no changes were necessary to get W3C compliant sessions from new browsers (Firefox 47+ and Chrome 75+).
For the Java bindings, it was decided to take this approach one step further. Instead of just sending along what was provided in both formats, the code converted capabilities from the legacy protocol to the W3C protocol on behalf of the user. The Selenium Grid makes use of this code, so, regardless of which client language sends legacy capabilities to it, the Grid translates it to the W3C protocol for communication with the driver and then re-translates the results back to the legacy protocol. Because the code must make some assumptions and guesses for this to work, there are a lot of frustrating edge cases.
For Selenium 4.0, the Ruby, JavaScript, and .NET bindings, each removed the handshake code, so no legacy commands are used. Due to some issues that couldn’t be resolved before freezing the 3.x code, Python is waiting until Selenium 4.9 to remove its handshake code. The Selenium team intended to continue to support both protocols in the Grid and Java bindings throughout the 4.x releases, but running test suites written for Selenium 2 on the Selenium 4 Grid resulted in a larger than expected number of failures. Half a dozen bugs were discovered, some with a large effect.
The code in question is sufficiently complex that fixing the bugs without causing new problems would be a significant challenge. As such, we’ve decided to start simplifying the code base again by explicitly not supporting capabilities and commands from the legacy protocol in any of the Selenium codebase. If you are using the latest version of Java Selenium, everything that will be removed has already been marked deprecated, so double-check your usage to ensure there aren’t any surprises.
If you’re interested in the nitty-gritty details of some of the issues we found exploring this problem, you can look at the discussion in Selenium Issue #10374.
For more information on ensuring compatibility with the Grid, please follow our Selenium 4 Upgrade Guide
In real estate, the mantra for finding a new house or office space is “location, location, location!”. It could be said that when working with Selenium, a critical aspect of writing tests is “locators, locators, locators!”. Having a robust locator strategy - in your app under test and in your test framework - is highly important for effective testing.
If you are a Pythonista like myself and using Selenium for your test automation, then there are some important changes coming to how locators are defined and used.
Sometime after Selenium 4.2, the Python Selenium bindings will remove locator-specific methods for finding elements. This means that the methods
driver.find_element_by_id("some_id")
driver.find_element_by_name("some_name")
driver.find_element_by_tag_name("some_tag")
driver.find_element_by_css_selector("some_selector")
driver.find_element_by_class_name("some_class")
driver.find_element_by_link_text("some_text")
driver.find_element_by_partial_link_text("some_other_text")
driver.find_element_by_xpath("some_xpath")
will be removed. All of these methods are in fact special cases of
driver.find_element(By_object, "some_locator")
so this approach is now preferred (required, even) with the Python bindings.
Note that it’s good practice to use the By object which has specific values for using particular locator strategies. For example, this line
driver.find_element_by_id("submit_button").click()
driver.find_element_by_css_selectors('.myelement child').text
becomes
driver.find_element(By.ID, "submit_button").click()
driver.find_element(By.CSS_SELECTOR, '.myelement child').text
If you’re really desperate however you can use strings instead of the By object:
driver.find_element('id', "submit_button").click()
driver.find_element('css selector', '.myelement child').text
If you have any plans to upgrade your Selenium client for your Python tests to recent versions of Selenium 4, definitely keep these changes in mind. It’s a good time to update your locator strategy and structure.
(This article was originally posted here. Thanks to the Selenium core contributors for adding this here!)
With the retirement of Internet Explorer 11 (IE 11) later this year, the folks in Redmond have helped the Selenium project with getting IE Mode in Microsoft Edge working in IEDriver.
IE 11 is due to retire on 15 June 2022 for certain versions of Windows 10. After this date, the Selenium project recommends that you test your IE sites with IE Mode in Microsoft Edge. The Selenium Project will not remove support for IE 11 when it retires but we will not actively fix issues as we have done with previous versions of IE.
The Microsoft Edge team have committed to supporting IE Mode in Edge until 2029 when support for Windows 10 is retired.
Microsoft have written up all the details on how to use and how to migrate your site and we recommend you go read and follow their steps to make sure you’re ready.
A while ago, we started to make the Selenium documentation available in more languages. This, in an effort to offer a more inclusive environment for Selenium users who do not have English as their mother tongue.
This effort grew organically, and we got many pull requests adding content for different languages. Over time, some translations got to a very good state, and others didn’t get much attention. This brought the situation where 9 different languages are available in the documentation, but only a few add value to the readers.
To understand which languages are getting visits, we started using Plausible. After a few weeks, we combined the information collected by the analytics tool with the translated percentage per language, and we got the following:
Here’s the number of visitors on the landing page for a given translation in the past 2 weeks, and the percent of documentation pages translated:
Language | Visitors | Translated |
---|---|---|
ja | 1,700 | 86% |
zh-cn | 1,500 | 86% |
es | 409 | 42% |
fr | 203 | 31% |
pt-br | 189 | 87% |
de | 88 | 65% |
ko | 79 | 68% |
nl | 22 | 6% |
This shows that the most used languages (aside from English) are Japanese and Chinese, and that the language that has translated most of the content is Portuguese.
Based on this data, we decided to create a new role in the Selenium project: translators. This role will help the project keep in shape the different translations available. Together with that, we are also putting on hold the other available translations until we find volunteers for each language.
If you have any questions or comments, please reach out through any of all the available options shown at our support page.
Stay tuned for updates by following SeleniumHQ!
Happy testing!
The short version is that I’m stepping down as the Selenium project lead, and will concentrating on pushing WebDriver Bidi forwards. Fortunately, the Selenium TLC have already been steering the project for a while now, so it’s in excellent hands. With Selenium 4 now shipped, the project has a new energy and enthusiasm about it. The future is bright, and I’m looking forward to seeing what it holds.
The longer version? Well, that’s more personal. Let me start at the beginning….
On the 3rd January, 2007 I pushed the initial commit of “WebDriver” to a public repo. I helped with the Selenium 1.0 release, and at the same time made sure that WebDriver emulated the original Selenium RC APIs (in code that lives on to this day). In 2009, Jason Huggins and I merged the Selenium and WebDriver projects, and I took over the leadership of the project. I’ve been the lead for every version of Selenium since then, often being the person who tagged each release in source control, all the way up to the recent Selenium 4 release.
By the numbers, that’s
In a way, I blame Michael C for this. He and I worked together at ThoughtWorks in Australia, and had been working with HttpUnit. My assertion was that its API was fine. His was that it should be more Object-Oriented. To explore the idea, I started writing an OO wrapper around HttpUnit, and (of course!) Michael was right.
Or maybe it’s Joe Walnes who I should be talking
about. At about the same, he’d been exploring a similar kind of
design, but where my API had a Browser
, his had the far better
sounding WebDriver
, and he was generous enough to allow me to use
the same name in my next iteration of the idea.
Or, perhaps, it’s Paul Hammant and ThoughtWorks. Paul was the one who suggested Open Sourcing what was then “WebDriver” under the Apache 2 license, and ThoughtWorks supported the decision to make the code available to the world.
In any case, on that day in 2007, I was sitting on the sofa with a glass of red wine, creating the project on Google Code, and thinking (if I was thinking deeply at all) that it’d be nice to get the code out there, and in six months it’ll probably be over. There was absolutely no way I could dream that the project would grow far beyond me, emerging from the Cambrian explosion of the early days of web testing to become first an industry-wide de facto standard, and then, through the work done in the W3C, an actual standard. It’s the only browser automation API that all the browser vendors support.
During these past 14 years, Selenium has been one of the constants of my life. I joke sometimes that I’ve known it longer than my wife and my son, but is it a joke if it’s true?
Why spend that much time and effort on Open Source? On something that you give away for free? Because it’s just been so incredibly rewarding. I’ve had a chance to meet people from all over the globe, work with amazing people from a range of companies I’d never have a chance of working with normally, learn and practice skills I wouldn’t have had a chance to exercise, and to write code that makes people’s lives just a little bit easier.
Most importantly, Selenium has been the way that I’ve met some of the best friends I have in my life. I’ve been very lucky.
I’ve also been lucky to have met and been part of the Selenium community. The conferences and meetups have been a fantastic way to hear about how people are using the tool, and I am constantly impressed by how inventive and thoughtful people can be. The conversations I’ve had at those events have changed how I think about all sorts of things, and not just code. The IRC and Slack channels are vibrant and interesting places to be. There are folks who are there regularly who I’ve never met in person, but who I feel I could count as friends.
Who knew that Open Source could be the source of so much that makes a life bright?
But today, I’m stepping down as the project lead, and will be away from the project until summer, though (in the true spirit of this project), I’m not sure which year.
Why, if all I said above is true, am I stepping down?
The major reason is that the things I like to do, and that I’m good at, are not the things that the project needs right now. It would be hubris to believe that no-one else could do as good a job, particularly when I know how amazing so many people on the project are.
The other reason is that I’m tired. For the past 14 years, much of my free time, as well as hours within work, has been spent working on Selenium. There are other projects and interests I’d like to pour some energy into (just ask me how my Turkish lessons are going!)
In my absence, the project’s “Technical Leadership Committee” will continue to be setting the direction of the project. I’ve been listening to the discussions about where the project can go: it’s going to be brilliant.
That is, while I’m stepping down, the rest of the TLC will be stepping up. They’ve already been running the project for a while. They’ll continue the work we’ve started and carry it forwards and upwards. If you’re reading this, and want to get involved, step in and join the fun. Now’s the perfect time.
When I took over as lead of the Selenium project, Paul joked that he had thrown me the keys and run in the opposite direction. I guess it’s my turn to do that now!
Before finishing, I’d just like to say a heartfelt “thank you” to everyone who’s been involved in the Selenium project. To everyone who’s contributed in some way, or used the code we’ve written, thank you. To everyone who’s filed a bug, thank you too. To all the people who I’ve had the pleasure of so many conversations with, that I would never have met without Selenium, thank you. To my family, who’ve supported me and understood with endless patience that Selenium is a part of our lives, thank you. And to my friends on the project, an extra meaningful thank you.
I won’t be here, but I won’t be far. See you all soon.
Before we ship Selenium 4, I thought it would be nice to introduce some of the new features in-depth. Of course, all of the features we’re covering are in the main WebDriver documentation, so if you’re not one for reading blog posts, then feel free to dive in there!
You may well be familiar with how to start a Selenium server: you just
do something like java -jar selenium-server-4.0.0.jar standalone
and
away you go! But with Selenium 4, there are some more things you can
do with this jar.
Least obviously, the server jar is an exectuable on its own. If you’re
using Linux or macOS, and have Java installed, you can make the jar
executable (eg. chmod 755 selenium-server-4.0.0.jar
), rename it to
something like selenium
and put it on your $PATH
. That way, rather
than writing java -jar ...
you can simply run selenium
.
Now you’ve done that, if you run selenium
with selenium --help
you’ll get a handy list of the available sub-commands you can
execute. There are the old favourites, such as standalone
(for
starting a standalone selenium server), and hub
and node
(for
starting a Selenium Hub and Node setup), but there are
other interesting commands that are new to Selenium 4.
The first of these is info
. We’ve added this to provide easy to find
and access documentation on common tasks when using the selenium
server. If you run selenium info
on its own, you’ll see something
like this:
Info
====
You can find out more about topics concerning Selenium Grid by running the
"info" command followed by:
* config - Help on how to configure Selenium
* tracing - Help on how distributed tracing works with selenium
* security - Help on how how to secure communications to and within selenium
* sessionmap - Help on different types of sessionmap and how to start them.
Each topic will give you enough information to help you get started, and contains
some pointers on our site to provide more complete information.
To get more information on a particular topic, just add the name of
the topic, for example selenium info security
. The hope is that this
will make it less daunting to deal with Selenium, and give you a great
place to get started with some of the more complicated topics around
running a Selenium Grid.
Although it’s incredibly flexible, the selenium
command offers a
daunting list of command line flags. How are you supposed to remember
them all? You’re not! Instead, let selenium completion
take the
strain for you. If you’re a zsh user, then just source <(selenium completion zsh)
, and now you have tab completion for the
sub-commands, as well as for all the flags, including examples of how
to use them.
And, finally, there are some hidden flags. We hid them because they
can be a little bit confusing to use or understand what they’re meant
to do, but one that can be very useful when debugging how your Grid is
configured is the --dump-config
flag. When run with a server command
such as standalone
or hub
, it will dump the configuration options
used by the Grid as a JSON blob. This can be helpful for tracking down
subtle issues with configurations, especially when using environment
properties for configuration.
It’s with very great pleasure that we are announcing the release of Selenium 4. This is available for Java, .Net, Python, Ruby, and Javascript. You can download it from your favourite package manager or right from GitHub!
If you’re already a Selenium user, this update should be as easy as just changing your dependency from 3.x to 4.0.0. We’ve worked hard to ensure that this is a “drop-in” upgrade, having focused on keeping the public APIs as stable as possible.
Of course, we’ve made changes, so if you relied on code that was marked as internal to Selenium, or that was deprecated, you might experience some hiccups. Please check our documentation for advice on how to deal with each of the common problems we’re aware of.
But there’s more to Selenium 4 than just being a stable release of what was there before! It brings a whole host of new and exciting features that we hope will make your tests more fun to write, and more stable when you run them. Let’s take a look at some of them!
We’ve introduced “relative locators”. These allow you to specify where on the page an element can be found using language that people use too; things like “above that element”, or “to the right of this other element”. This will hopefully provide you all with a tool to fight against incredibly complex locators, making your tests read a little more clearly, and being more resilient to changes in the page’s DOM. We’re not the first ones to come up with this idea – that honour belongs to Sahi – but if you’ve not used them before, we hope you like them!
If you’re using Firefox or a browser that is derived from Chromium, we’ve added a slew of new capabilities too. These include ways of handling “basic” and “digest” authentication, Network Interception (Are you an HTTP 418?), and also performing commonly requested tasks, like waiting for a change in the DOM, or providing a way to look at Javascript errors.
We’ve added these new features in a way that fits in with our existing APIs. There’s no need to rewrite your tests: just use the new features when it feels right to you.
We have also rebuilt the Selenium Grid, taking lessons from successful projects such as Zalenium and Selenoid to enhance the capabilities. This new Grid runs just as well as a single process, running on a single machine, as it does in the traditional “hub and node” configuration, but it also supports a fully-distributed mode, for use in modern infrastructure running Kubernetes. It has better security baked-in, because we know that securing a Grid can be a difficult task. And at all of these scales and sizes, all the new features we’ve added to the language bindings will work as expected.
The Grid can also manage Docker containers on your local machine, pulling images such as the standalone firefox server so your infrastructure maintenance becomes just a little bit less taxing.
Finally, the Grid is easier to manage. We’ve revamped the UI, placing it on top of a GraphQL model that anyone is free to query and make use of to create their own visualisations or monitors of the Grid. If you’d like to peek into a running session, there are live VNC previews you can open and interact with, providing even better insight into what’s been going on. And if you want even more information, we’ve integrated support for OpenTelemetry into the Grid, so now you can find out exactly what’s happening, where, and when.
I know it’s a cliche to say that it’s a “very great pleasure”, but, being honest with you, it genuinely is. Working on this new version of Selenium has been a chance to work with some amazing engineers, and to be part of a vibrant and energetic community. It’s been a lot of fun to write this code, with these people, and it feels right to say “thank you” to as many of them as possible here. So, without waiting any longer….
We would like to thank all of our users who have helped Selenium be successful over the years. Without you we wouldn’t be where we are today. We would also like to thank all the contributors who have submitted Pull Requests, your contributions make Selenium better. For everyone who’s taken the time to file an issue, and to let us know where there’s been a problem: thank you. We only have a chance to improve when we know that there’s something that needs work!
And finally, thank you to all the Selenium Committers, BrowserStack, Sauce Labs, and our Selenium-Level sponsors for getting this release ready for our users.
We hope you enjoy Selenium 4, and we can’t wait to see what you do with it!
Before we ship Selenium 4, I thought it would be nice to introduce some of the new features in-depth. Of course, all of the features we’re covering are in the main WebDriver documentation, so if you’re not one for reading blog posts, then feel free to dive in there!
The first thing I’d like to introduce you to is Selenium 4’s new-found
ability to authenticate to websites. We’ve always been able to handle
“form-based” authentication, where a login page has some INPUT
elements that you need to enter the user name and password, but
handling sites that use basic or digest
authentication has always been harder. When using
Selenium 3, the advice has been to get the login cookie and set it on
your session before accessing the site, but you can now just call a
register
method to add a user name and password (or, in the future,
other kinds of authentication credentials)
In short, in Selenium 4, the process has become less complicated. Perhaps an example will help?
// This "HasAuthentication" interface is the key!
HasAuthentication authentication (HasAuthentication) driver;
// You can either register something for all sites
authentication.register(() -> new UsernameAndPassword("admin", "admin"));
// Or use something different for specific sites
authentication.register(
uri -> uri.getHost().contains("mysite.com"),
new UsernameAndPassword("AzureDiamond", "hunter2"));
driver.register(username: 'admin', password: 'admin')
Once you’ve done this, every time the driver
loads a page that needs
authentication, it will automatically use the user name and password
you’ve given it.
This feature is currently implemented on top of Selenium 4’s CDP support, and so only works on those browser that support that protocol, but as we push forwards with development of WebDriver Bidi implementations will switch to that when they can.
We’ve listeneed and responded to the feedback from the first release candidate of Selenium 4, and we’re now happy to announce the second release candidate of Selenium 4. This is shipping for .Net, Java, Python, Ruby, and Javascript, and it’s available from all the popular package managers. Go! Try it out!
Unless we encounter a very serious issue or bug, this is likely to be the last release before we push Selenium 4.0.0 itself. What does this mean for you? It’s your last chance to try it on for size and let us know if there are any problems.
In this release, we’ve fixed a nasty issue where closing the first window would cause CDP-related features to break, and have landed a few other cleanups and fixes.
If you’re a Firefox user, please make sure you’re using the very latest version of the geckodriver If you don’t, there may be problems starting sessions as we rely on new features that are included in this new geckodriver release.
If you’re new Selenium 4, then you may want to read this blog post, which explains more, but you might want to have a look at:
Thank you to everyone in the community who’s given us so much helpful and thoughtful feedback on the first release candidate. We really hope that you enjoy this release candidate too!
#Selenium 4 RC 2 has been tagged! This is the final RC before we do our final release! Go start using it! Details of each of the bindings will be found in the thread below!
— David @automatedtester@mastodon.social (@AutomatedTester) September 30, 2021
#Selenium 4.0 RC2 .NET bindings have been released! This will likely be the last release before 4.0 stable release, and the last chance to fix issues before then, so go try it out now. Get the bindings at https://t.co/wGImsWFfCK or via #NuGet.
— Jim Evans (@jimevansmusic) September 30, 2021
#Selenium 4.0.0.rc2 #ruby gem has been published. All of the less pleasant work went into this one - polishing and making sure things match up between the different bindings, etc. This should essentially be Selenium 4, so upgrade already and tell us what you think!
— Titus Fortner (@titusfortner) September 30, 2021
Exciting times! Selenium 4.0 RC2 for Java has been released. We're planning on this being the last release before the stable 4.0 release, so this is your last chance for you to give us feedback and for us to react before then! #selenium4
— Simon Mavi Stewart (@shs96c) September 30, 2021
We’re very happy to announce the first release candidate of Selenium 4. We’re shipping this for .Net, Java, Python, Ruby, and JavaScript, so if you’re using any of those languages, go and grab it from your package manager of choice!
This release is the result of a lot of work by the Selenium team project, but most importantly, all the Selenium community who tried our beta releases, and gave us great and valuable feedback.
#Selenium 4 Release Candidate for #ruby is now available! There should be fewer problems running against latest versions of browsers now than with Selenium 3. Please update and let us know of any problems so we can get the production release out the door. https://t.co/JWbwDRPcj4
— Titus Fortner (@titusfortner) September 1, 2021
So, big news: #Selenium 4.0 RC1 has just been released! The .NET bindings are available via #NuGet, or you can find them at our new binary release point, https://t.co/CSNK7K47ue. We're closing in on a final, stable 4.0 release, so if you haven't tried it before now, you should!
— Jim Evans (@jimevansmusic) September 1, 2021
#Selenium 4 RC1 is out! The #python bindings are available at https://t.co/B4zKI6JQkA pic.twitter.com/kMlDM4ad7I
— David @automatedtester@mastodon.social (@AutomatedTester) September 2, 2021
Hurrah! #selenium4 RC1 is out, and the Java bindings have been released! Grab them from your favourite maven repo, or download the binaries from https://t.co/XUcv7RzbzL pic.twitter.com/E9T1ZTZ9jd
— Simon Mavi Stewart (@shs96c) September 2, 2021
@SeleniumHQ 4 RC 1 is out! This means that Selenium 4 is getting closer and closer 🎉🎉
— Diego Molina (@diegofmolina) September 6, 2021
Try out the new Grid through our @docker images -> https://t.co/lGUrZAQneJ pic.twitter.com/BzZxPn3p0y
One thing you may want to do to get ready for the update (which you can do before updating the dependency itself!) is to update the drivers you need. In particular, please update geckodriver to 0.29.1 or later.
Most of the new features in Selenium 4 are mentioned in this blog entry, but the main highlights are:
If this sounds interesting, please download the release candidate from your favourite package manager (maven, nuget, npm, pip, or the gem), or directly from the Selenium site.
We announced on a previous entry our decision to move all binaries from Google Storage to GitHub releases. Today, we would like to announce that this work has been completed and all binaries are also available to be downloaded in each one of the releases we have done in GitHub.
In addition to that, all links on our downloads page have been updated, as well as all references to Google Storage in the Selenium code base.
Please note that all past releases will be available both in Google Storage and GitHub releases, but new ones will only be present in GitHub releases. We recommend everyone to modify your download scripts to keep all tooling up to date.
If you have any questions or comments, please reach out through any of all the available options shown at our support page.
Stay tuned for updates by following SeleniumHQ!
Happy testing!
Thanks to Google, Google Storage has been the central place where we have been able to upload all binaries created for each Selenium release, and the place where the Selenium community can download them from. To do so, all people needed to do was visit our downloads page, find the release, and download from there!
The Selenium project hosts its source code on GitHub, and people who are familiar with GitHub know that they can go to the “release” page there to find any downloads for each release of a project.
Rather than hosting the downloads in two places, the Selenium project has decided to host everything on GitHub. We’ll still have links from the download page, but rather than pointing to Google Storage, these will now point to the downloads for each corresponding release tagged on GitHub.
All past releases will be available both in Google Storage and GitHub releases, but new ones will only be present in GitHub releases.
If you are a watcher of the Selenium repo, please note that there will be some noise in your inboxes. We need to create releases for old tags in order to upload the binaries to the release (as is the way GitHub releases work), and we expect to complete this in the next couple of weeks.
If you have any questions or comments, please reach out through any of all the available options shown at our support page.
Stay tuned for updates by following SeleniumHQ!
Happy testing!
We have been working hard during the last few weeks redoing our website. Today, we are very happy to share it with the community and we are hoping to get as much feedback as possible!
We did a major revamp to our website two years ago. However, this revamp had some “technical debt” in it…
We're happy to announce that we have (finally!) refreshed our site. Head on over to https://t.co/0xAiKdHrPj and have a browse! Thanks to @diegofmolina and @manoj9788 for making this happen.
— Selenium (@SeleniumHQ) November 12, 2019
We use Hugo to generate our website, and to build a website with Hugo, one normally needs to select a Hugo theme. Our previous website was being built using two different Hugo themes, which was less than ideal. Having two Hugo themes was hard to maintain and accepting contributions was tricky in some cases.
This new website version is using the Docsy theme, made by some folks at Google and used by other popular projects such as Apache Airflow and Kubernetes. Using Docsy helps us to focus more on the website’s content rather than spending lots of time maintaining the underlying details of it.
We all hope you will like the new look and please check our contribution guidelines if you want to contribute to the Selenium website.
Happy testing!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on July 15, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:00 PM
Here is the agenda proposal:
Previous meeting: 170 open issues, 23 open pull requests
Currently: 168 open issues, 25 open pull requests
Pending work for the RC 1?
Server - Grid
Hub reports Nodes going down https://github.com/SeleniumHQ/docker-selenium/issues/1257
TimeoutException https://github.com/SeleniumHQ/selenium/issues/9528
IE Stopped working on beta 4 https://github.com/SeleniumHQ/selenium/issues/9600
Language bindings
“se:cdpVersion” is missing in C# and JS
Can all bindings do CDP over Grid?
Do all bindings implement them
9:01
@AutomatedTester @Puja Jagani @barancev @jimevans @titusfortner @p0deje @harsha509 please tag the ones I forgot
Titus Fortner 9:02 PM
Documentation theme change update
9:03
(I know you’ve been busy)
David Burns 9:04 PM
The python ci will be green today
Diego Molina 9:04 PM
ok, so let’s start
Regarding bugs we had, with @Puja Jagani we fixed the queue issue, so now the Grid runs enough sessions in parallel
9:05
but we still have 3 open issues, mentioned in the agenda
the timeout one has proven to be hard to reproduce, and therefore fix
David Burns 9:05 PM
I was able to reliably recreate the timeout issue. We were hitting issues in chrome that makes us think chrome is breaking
Diego Molina 9:06 PM
really? The original issue is reported with Firefox
David Burns 9:06 PM
Well, I am getting the timeout message, like with Firefox, with chrome 91
9:07
And it’s like the browser tab has hung/crashed and it manifests
@Puja Jagani has the script and I will help reduce if I can
Simon Stewart 9:07 PM
I need to do some rework of NetworkInterceptor to allow everything to be intercepted
9:08
And I think https://github.com/SeleniumHQ/selenium/issues/9594 is fixed by https://github.com/SeleniumHQ/selenium/commit/0795e78559924be1b69b4c8051f5185f289a4268 #9594 Hub reporting no available nodes after a few hours https://github.com/SeleniumHQ/selenium|SeleniumHQ/seleniumSeleniumHQ/selenium | Apr 8th | Added by GitHub
Diego Molina 9:08 PM
I think @Puja Jagani saw the issue this morning, and she said she was having a look
Simon Stewart 9:09 PM
Darn it. I thought we had it fixed
Though we don’t handle the case automatically. I manually tweaked things to make that work
David Burns 9:09 PM
Shoutout to Puja for looking at ALL THE THINGS
Simon Stewart 9:10 PM
+1000
Diego Molina 9:11 PM
aside from those two, now looking into the IE issue with Grid\
as the Grid is sending and invalid JSON to the IEServer
Jim Evans 9:12 PM
um, se:cdpVersion was implemented in .NET in f10cb89
Simon Stewart 9:12 PM
Woot!
Diego Molina 9:12 PM
great, I will update that item :tada:
on the client side, we still need to find time to build the feature parity doc
9:15
Aside from those items, I can give an update on the new (or reworked) website
9:16
I’ve been spending 1-2 hours per day, for now I am only building the website as it is, not digging into the docs yet
Titus Fortner 9:16 PM
“digging into the docs” == “updating the docs theme” ?
Diego Molina 9:16 PM
so, everything below the about menu is already implemented
Titus Fortner 9:16 PM
or writing the docs
Diego Molina 9:17 PM
and I still need to create pages for these links
Titus Fortner 9:18 PM
that all looks great!
Diego Molina 9:18 PM
to bring context, our website is made from two different Hugo themes, glued together during the build process and a few hacks in between
I’ve found https://www.docsy.dev/ a good alternative since it offers a good theme that can contain both things in one
9:19
this requires to recreate our website using the docsy theme, this part is around 60% done then we need to migrate the existing docs into the new theme
9:20
migrating the docs could be done as a task of copying and pasting or we could see it as a chance to reestructure and organise the existing content, and adding a few things more
9:21
if we want to reestructure, it would be nice to see proposals (like a global TOC with brief descriptions of each item)
9:21
then we can reuse what we have currently, and add what is missing
Titus Fortner 9:22 PM
So code snippets would look like this: https://gist.github.com/harsha509/e690dd2c72f1f5c5785be4c8a47c87fd
Simon Stewart 9:22 PM
Lift and shift first, rework second
Diego Molina 9:22 PM
code snippets is an implementation detail
Simon Stewart 9:22 PM
(That is, let’s open the door to contributions first, then figure out how things should be shaped)
Titus Fortner 9:22 PM
I get it’s implementation
9:23
but that’s the piece I can help with :slightly_smiling_face:
Diego Molina 9:23 PM
right now they look similar to that, so it could be a matter of adjusting things
9:24
ideally, the future for code snippets is to render code stored in GitHub, so we can execute it in GitHub actions for example
Titus Fortner 9:25 PM
I guess the question I had about it (what I tried to figure out a few months back and failed) is if there’s a way to point to a repo like you & Christian built for Docusaurus :smile: (another implementation detail) But… there’s nothing preventing us from writing that code now and figuring it out later
David Burns 9:25 PM
I like rust for this reason… when you run tests it also tests the doc snippets
Titus Fortner 9:25 PM
@p0deje implemented that for Ruby
9:26
it’s really neat
I’ll try to find time to propose something here and try to get feedback from people smarter than I am about these things https://seleniumhq.slack.com/archives/CBH302726/p1626364266427200
Diego Molina
if we want to reestructure, it would be nice to see proposals (like a global TOC with brief descriptions of each item) Posted in #selenium-tlc | Today at 9:21 PM | View message
Diego Molina 9:28 PM
all WIP is committed, so if someone wants to have a look, please check https://github.com/SeleniumHQ/seleniumhq.github.io#wip-moving-to-hugo-docsy-theme
SeleniumHQ/seleniumhq.github.io Official Selenium website and documentation Website https://selenium.dev/
Titus Fortner 9:29 PM
Nice work on all of that
Simon Stewart 9:29 PM
Agreed. Excellent work, @diemol. Thank you
Diego Molina 9:29 PM
hopefully I can have the site migrated in a couple of weeks, then we have focus on the docs
9:30
I do not have any more topics, does anyone have something else?
Titus Fortner 9:31 PM
Hopefully I’ll have all my ${paidWork} code in a good place at that point to take a break
9:32
I also promised the chromedriver team that I’d help fix up their Ruby code
Lots of things to update
9:33
Right now I’m busy updating all of my Java test examples from JUnit 4 to JUnit 5 thanks to @Puja Jagani
Diego Molina 9:36 PM
ok, so it seems we are done with today’s public meeting, thank you everyone!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on June 17, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 8:52 PM
Here is the proposed agenda:
After beta 4, we should document how each binding and the Grid are released
Who knows what the release process is? What is needed?
Who can help reviewing pull requests?
#1257 Hub reporting no available nodes after a few hours SeleniumHQ/docker-selenium | Apr 8th | Added by GitHub
#9528 java.util.concurrent.TimeoutException thrown at random netty read timeouts with RemoteWebDriver SeleniumHQ/selenium | May 28th | Added by GitHub
8:56 PM
btw, there is no hurry to start, we can also start when most folks are available, I believe this won’t be a long one
Diego Molina 9:01 PM
Just a comment from the increased number of issues… I believe users are starting to give more feedback, so that’s good
9:05 PM
I believe we can slowly jump into the first topic: Pending work for the RC 1?
9:06 PM
Regarding the Grid, I would say it is feature complete
9:07 PM
but we have a couple of bugs we are checking with @Puja Jagani
9:08 PM
I think we can sort them out during the next week (fingers crossed :slightly_smiling_face:)
Diego Molina 9:13 PM
talking about the language bindings, I think the most relevant thing for RC1 is to check feature parity
Titus Fortner 9:14 PM
@AutomatedTester did the shadow Dom work you did end up in geckodriver /Firefox yet?
9:15 PM
I know some bindings implemented the endpoints already
David Burns 9:15 PM
No, it’s nearly done
Maybe I should hand it to the Mozilla folks and maybe they could finish it off
Titus Fortner 9:15 PM
I kind of wanted to wait until I could make sure tests passed and stuff because I never trust myself :)
David Burns 9:16 PM
There is an issue with something between marionette and geckodriver but those are super hard to diagnose
Titus Fortner 9:17 PM
There were some accessibility endpoints? I’m not sure we’ve all added. And I think ruby deprecated methods that other languages implemented with JS
I’ve been meaning to do a deeper dive into the various tests, but haven’t gotten there yet. Ruby broke CDP in last beta release, we need to figure out
9:21 PM
We probably need to do a beta 4.1 just for ruby with that fix
Diego Molina 9:22 PM
Since the VNC stuff has been implemented, I have a bit of time next week to start working in an issue to document feature parity
Titus Fortner 9:23 PM
I’ll dedicate some time this month to helping with it
Probably the last topic is Release process
9:24 PM
Last week Simon recorded the Java release and shared the video so I can document it
It’d be great if the other folks who also do releases do the same, so we can document and potentially automate releases
Diego Molina 9:30 PM
I believe that was everything we had in the agenda
Titus Fortner 9:36 PM
Documentation. We got an offer from a company to help us with documentation so they can integrate it with their product which is an executable browser IDE thing
Or something. I’m not entirely certain, but sounds potentially interesting.
Diego Molina 9:37 PM
tell us more, @titusfortner :slightly_smiling_face:
Titus Fortner 9:37 PM
I at least want to get a demo and see what they mean.
I don’t know more, yet. :)
Diego Molina 9:37 PM
ah ok, they reached out to you privately :slightly_smiling_face:
Titus Fortner 9:38 PM
Yeah, I’ll loop you in when we set up a demo. Might not work for what we need
Diego Molina 9:39 PM
sounds good
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on June 03, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:01 PM
:wave: Anyone around for our public meeting? @barancev @manoj9788 @mmerrell @simonstewart @harsha509 @Puja Jagani @AutomatedTester @titusfortner @p0deje @jimevans
9:02 PM
Let me post our ongoing agenda
Who knows what the release process is? What is needed?
Who can help reviewing pull requests?
please feel free to add any topics you’d like to add
Todd Tarsi 9:04 PM
I have been puttering on running ide v3 inside of ide v4, and it is kinda coming along. I’ll just post a screencap of where it’s at when we get there
Simon Stewart 9:04 PM
Agenda LGTM
Diego Molina 9:05 PM
A comment on General project statistics It feels as if folks are trying betas a bit more, I see an increase of issues
Simon Stewart 9:06 PM
That’s a Good Thing.
Diego Molina 9:06 PM
Most of the Grid ones can be fixed with docs, so I can take time to do that
other ones, seem to be either bugs or people just figuring out how to use beta 3, not sure
Simon Stewart 9:06 PM
I got some informal feedback from someone who said “btw it seems a ton more stable than 3.141.59 for us on soak test”.
Diego Molina 9:06 PM
That is nice to know
Simon Stewart 9:06 PM
Are there any issues we should be prioritising?
I’ve not read them recently, but if there’s a theme, we can try and address the systemic causes
Diego Molina 9:09 PM
We also have a few PRs pending to review, some of them related to the Grid, which @Puja Jagani created, and maybe when things are less intense, you could have a look @simonstewart, please?
Simon Stewart 9:10 PM
Sure. I’ll get on that ASAP
Diego Molina 9:10 PM
ok, so Pending work for the Beta 4?
Simon Stewart 9:11 PM
Just the .Net bindings, I think New
Diego Molina 9:11 PM
and I believe @Puja Jagani tackled “Check that the Redis/JDBC backed services actually function”, not sure
Simon Stewart 9:11 PM
I think so, just checking
Simon Stewart 9:11 PM
I think so, just checking
9:12 PM
Yeah. We follow the spec better now
Before rc1, I’ll do some more command line testing of it using curl. I bet I can still make it fail
Diego Molina 9:13 PM
I was going to start working on “Pipe VNC connectors through the WebSocket plumbing for live video” but I bumped into the StressTest not passing, which lead to a fix. I want to have this before RC1, hopefully for beta 4
Simon Stewart 9:13 PM
Hopefully the infrastructure you’ll need is already in place.
I guess you’re going to expose a se:vnc capability or similar?
Diego Molina 9:14 PM
yes, that is the idea
Simon Stewart 9:14 PM
Perfect
Which reminds me, we should make sure that both Sauce and BS know that the Selenium 4 local ends will all try connecting to se:cdp and their infra could/should/might want to handle that
Titus Fortner 9:18 PM
local ends should only try connecting to that endpoint if using a devtools feature. Might make sense to just let it error out as unknown endpoint if it isn’t supported.
Diego Molina 9:18 PM
We are working internally on that, everyone at Sauce is aware :slightly_smiling_face:
Simon Stewart 9:18 PM
@titusfortner that’s what the java code does
@diemol that’s great news :slightly_smiling_face:
Diego Molina 9:20 PM
Ok, so Language bindings
I am not sure if @harsha509 and @AutomatedTester had time to use that in the JS bindigns
Simon Stewart 9:21 PM
If bindings are using se:cdp properly, then they should be able to do CDP over Grid.
Sri Harsha 9:22 PM
No @diemol. As discussed in last we punt it to rc1. If time permits i will look into it for sure
Simon Stewart 9:22 PM
I think the .Net bindings aren’t aware of the se:cdp capability yet
A quick grep suggests that’s true
Diego Molina 9:22 PM
thank for the update, @harsha509!
ok, so maybe we can jump to the next topic:
I have not been able to get this list done, lack of time and also I do not know where to start to get this information
9:26 PM
from the top of my head, is:
9:26 PM
any others?
Sri Harsha 9:26 PM
JS bindings doesnt have /session/{session id}/element/{element id}/shadow endpoint implemented
9:27 PM
not sure of other language bindings
computedRole
computedLabel
Titus Fortner 9:28 PM
Do any of the drivers have shadow endpoint implemented?
Simon Stewart 9:28 PM
I’ll wire that into Java next week
Jim Evans 9:28 PM
working away at .NET to get ready for beta. :tada: 4
Simon Stewart 9:28 PM
I may wire in a fallback too
Jim Evans 9:29 PM
i want to also include the shadow endpoints, but i may not get to that.
Simon Stewart 9:29 PM
It can wait for rc1.
9:30 PM
For the record, I’m thinking of rc1 as “if we want to, we could tag this as 4.0 and be done”, so until we ship that, we don’t need all the commands in place. :+1: 1
9:30 PM
I’m seriously hoping beta4 is the last beta
Titus Fortner 9:31 PM
So, it’s not explicitly on the agenda, but relates to the languages implementing everything….
documentation.
Would be nice to have something that explains everything that is new with examples in each of the languages
9:31 PM
(as in I am willing to help not just complain about this one)
9:33 PM
but…
Do we still want to update to a different theme first?
Would it be possible to get help from a “Technical Content Strategist” or the like to help us organize things?
Diego Molina 9:33 PM
that is my idea by listing the features and seeing where they are implemented and where they need to be implemented :+1: 2
Sri Harsha 9:33 PM
I have tried my best to provide examples for all language bindings and a note on top of it like https://www.selenium.dev/documentation/en/webdriver/browser_manipulation/#create-new-window-or-new-tab-and-switch
Simon Stewart 9:34 PM
@titusfortner a human’s guide to the new features is a good idea.
Titus Fortner 9:34 PM
After spending a little time with the Sauce tech content team it has really showed me how much of a difference it makes to have someone who does this for a living organize things
I can look at something and say “this structure doesn’t make sense,” but my solution will be something that also doesn’t make sense. :smile:
Diego Molina 9:36 PM
I want to move to Docsy, a hugo theme that helps us to have website and docs in one single place
Titus Fortner 9:36 PM
and if we can reference code snippets from selenium repo tests rather than having to create/maintain them independently in our docs that would be huge
Is docsy the one I was looking at last time (whenever that was)?
Simon Stewart 9:36 PM
@diemol can the move to docsy be done at the same time as the docs themselves are updated?
Diego Molina 9:36 PM
and I have found Hugo shortcodes that can render real tests hosted in GitHub repositories, so we can run those tests in GitHub actions and provide working examples :tada: 2
Simon Stewart 9:37 PM
Oh! That’s nice!
Diego Molina 9:37 PM
I want to move the website first and leave for last the docs, but it will be hard to sync things, but it can be done
Titus Fortner 9:38 PM
I feel like if we have
then it’s just a matter of finding the test code in the project for each feature
Diego Molina 9:39 PM
nro. 2, is the Hugo shortcode I found
Titus Fortner 9:39 PM
and I’d like to propose we actually look to hire someone to help us with #1.
Top notch documentation for Selenium 4 could make all the difference
Simon Stewart 9:39 PM
We can easily set up an “example” repo that people can look at
Titus Fortner 9:40 PM
@diemol yeah, I just need an example in the template we want to use, because that’s what I was missing the last time I tried to help :slightly_smiling_face:
Luis Correia 9:41 PM
sorry for intruding, the documentation so far is too “surgical”, lacking proper context. I would provide a full Java/C#/Python Class/Snipped with inline comments that would explain constructs
Titus Fortner 9:41 PM
I loaded the new template, spent like 8 hours tyring to figure out how to get tabs to work, and then gave up. :smile:
Luis Correia 9:42 PM
bonus points would go to code interacting with an example website
Diego Molina 9:42 PM
This is normally the type of thing that gets done when someone spends a few days working on it and then enabling others to work :+1: 1
9:42 PM
So hopefully I can have time for that after beta 4 is released
Titus Fortner 9:43 PM
I think if I understood Go better I might have been successful
9:43 PM
it just is very different from Docusaurus and Jekyll which are the 2 static site implementations I’ve worked with
and I like @Luis Correia’s point about more context
Diego Molina 9:43 PM
We can pair on that, I don’t know Go so much, I just know how to copy & paste properly
Titus Fortner 9:44 PM
but as someone who writes things with a lot more context, it’s also a *much more significant undertaking
9:44 PM
Watir we have the inline docs that are surgical, then “guides” on our website that try to explain things
And we have examples in each of the repos against our test server
something we might do is publish the test server on selenium.dev so anyone can run their own code against it without having to build selenium?
9:45 PM
I did that for the watir test code as well
Luis Correia 9:46 PM
yes, public test servers are a good thing
I can help testing and correct testing code (mainly for Java) against that server
I’m kinda “well versed” into Maven build cycles and can probably help the project in that respect
Titus Fortner 9:48 PM
I just copy/pasted everything to the examples directy: http://watir.com/examples
People can change url_for(“forms_with_input_elements.html”) in the specs to “http://watir.com/examples/forms_with_input_elements.html"
Diego Molina 9:48 PM
maybe we can jump into the next topic? Release process
Titus Fortner 9:52 PM
For Ruby you need an account on rubygems. We can probably set one up a common email @selenium.dev with a secret password
9:53 PM
we can build the gem with bazel now, but the actual release requires manual intervention still
but I think we all agree that it is needed and we can do it after Se4 release
Diego Molina 9:56 PM
Something we were talking yesterday was to record the release process in a zoom call or similar and some of us who have more time, can document that process
Simon Stewart 9:58 PM
The java process isn’t too taxing
9:58 PM
The main thing is you need a Sonatype OSS account so you can publish the artifacts
Diego Molina 9:59 PM
so I believe we can focus on this topic a bit more when we feel close to beta 4 release?
Titus Fortner 10:01 PM
or RC :slightly_smiling_face:
Simon Stewart 10:03 PM
We are close to the b4 release :slightly_smiling_face:
@titusfortner getting the leg-rc package working properly again is on my list
Diego Molina 10:04 PM
I think we should find a way to document releases sooner than later because I imagine we will need to iterate faster when RC1 happens
Titus Fortner 10:04 PM
I meant release candidate version vs beta 4, not the RC package, but sure :wink:
Simon Stewart 10:04 PM
@barancev and I both have the keys for java releases
Diego Molina 10:11 PM
ok, I guess the idea would be to simply record those sessions
Sri Harsha 10:11 PM
Coming to Selenium-ide, I have the production build from V3 branch.
At the time of release i can change the build version, build, zip it and pass it over to someone who has access for release
Titus Fortner 10:11 PM
:thumbsup:
Diego Molina 10:12 PM
but I think we can chat more about this when we are actually going to release beta 4?
10:13 PM
Good idea to jump into the next topic :slightly_smiling_face:
Selenium IDE
so releasing it is as easy as uploading the zip somewhere? to the browser stores?
Todd Tarsi 10:16 PM
I can help review pull requests, but I don’t have any permissions around that stuff. Would reviewing PRs stil lhelp?
Diego Molina 10:17 PM
that would definitely help
Todd Tarsi 10:17 PM
Sounds good, I’ll take up a more active role reviewing PRs then.
Diego Molina 10:18 PM
I can help with merging if needed :slightly_smiling_face:
but we really need to figure out how to release
Todd Tarsi 10:18 PM
The release process seems like something that shouldn’t be that complicated. We build for edge, firefox, and chrome and then upload the zip files to the stores, right?
Sri Harsha 10:18 PM
Yes @diemol. Uplaoding the zip in webstore who has release access
Diego Molina 10:18 PM
I will try to ping Dave and Tomer privately
Simon Stewart 10:18 PM
Thank you @Todd Tarsi Helping to review things would be really helpful
There’s a chance I have access to the release account
Sri Harsha 10:19 PM
i asked @corevo . He said @simonstewart may have access to webstore to publish
Simon Stewart 10:19 PM
At least for Firefox, and maybe Chrome
Diego Molina 10:20 PM
sounds good, that would help a lot
Simon Stewart 10:22 PM
Will check tomorrow
Yesterday, 19 May 2021, all the staff of Freenode, the IRC network, collectively resigned as staff because of what they felt was a hostile takeover.
Freenode has always been seen as the home of Free and Open Software, so it was natural that you could find us on the #selenium channel there. To maintain this openness, and inclusivity, we are moving our IRC Channel over to Libera.chat. It is has been created by the team that previously maintained Freenode.
We are in the process of moving our Slack-to-IRC bridge over and hopefully the matrix bridge will be created soon so that we can have a free and inclusive project on the new IRC Servers. There may be a few hiccups so if you could bear with us.
If you have any questions please feel free to reach out to me on twitter or on one of the chat protocols we support.
Finally, thank you to “Milen from Bulgaria” for helping secure the channel for us on Libera.chat.
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on May 20, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Simon Stewart 9:00 PM
@AutomatedTester, @p0deje @titusfortner, @harsha509 @Puja Jagani @barancev @jimevans @Todd Tarsi and anyone else who’s interested, come on down!
9:00 PM
Any agenda items?
Diego Molina 9:00 PM
I can paste the ongoing agenda and leave you to it :slightly_smiling_face:
Simon Stewart 9:00 PM
Yes please!
Diego Molina 9:01 PM
:boom: Regression Report
We used Selenium Grid 2 and 3 to run multiple IE sessions in parallel without issues for many years. But now Selenium 4 restrict the number of IE sessions to only 1 without any way to override the restriction.
Last working Selenium version
Worked up to version: 3.141.59
Stopped working in version: 4.0.0-alpha
Simon Stewart 9:01 PM
Thank you!
9:01 PM
I’ll add: What do we want in RC1?
9:01 PM
Anyone want to add anything else?
Diego Molina 9:02 PM
Also
9:02 PM
(so, I cannot run the meeting, but I am around :slightly_smiling_face:)
Simon Stewart 9:02 PM
It’s much appreciated. Thank you, @diemol
9:03 PM
I’m guessing silence means that there’s nothing else to add?
In that case: Pending work for beta 4
Simon Stewart 9:04 PM
I saw that @Puja Jagani has got tracing working again, which I’d love to see in b4.
Puja Jagani
Will be landed tomorrow!
Simon Stewart
Woohoo!
Simon Stewart
Thank you :slightly_smiling_face:
Simon Stewart 9:04 PM
And @diemol posted a video of the Grid scaling up to 50 clients
9:04 PM
I’ve done some perf work to get better utilisation
9:05 PM
And we’ve unified the session queue too
9:05 PM
That is, I think Grid is good to go for b4 once the tracing work is landed
9:05 PM
Anyone (@harsha509 @AutomatedTester) know about se:cdpVersion in the JS bindings?
David Burns 9:07 PM
I’ve not done it
Simon Stewart 9:07 PM
(I see that @harsha509 is typing….)
Sri Harsha 9:07 PM
cdp version check is not implememted on js.
Simon Stewart 9:07 PM
OK. Do we need it for beta 4, or should we punt it to rc1?
David Burns 9:08 PM
We can punt it
Simon Stewart 9:08 PM
Great. Let’s punt it to rc 1
David Burns 9:08 PM
No one has noticed how it works and no bug reports so…
Simon Stewart 9:08 PM
What about CDP over the Grid?
If you’re using se:cdp for the websocket endpoint, it’ll work
9:09 PM
(@titusfortner and @p0deje I’m curious about the ruby bindings and CDP-over-Grid too)
David Burns 9:09 PM
That is there already
Titus Fortner 9:11 PM
yeah, for Remote, Ruby gets the version from se:cdpVersion
9:12 PM
We run the tests for both local and via the Grid, and everything is passing
Simon Stewart 9:12 PM
Do the Ruby bindings use se:cdpVersion too?
I guess you lean into the typing less than Java and .Net, so maybe it doesn’t matter so much
Titus Fortner 9:13 PM
capabilities[‘se:cdpVersion’].split(’.’).first
https://github.com/SeleniumHQ/selenium|SeleniumHQ/seleniumSeleniumHQ/selenium | Added by GitHub
Simon Stewart 9:13 PM
Perfect :slightly_smiling_face:
9:14 PM
waits for @titusfortner to type
Titus Fortner 9:14 PM
no need, I’m not saying anything useful
9:14 PM
but Ruby & devtools things I think we’re good
Simon Stewart 9:15 PM
Great. Moving on, then!
9:15 PM
I get the feeling that if anyone had the time and energy, @jimevans would appreciate a hand with the .Net bindings
9:16 PM
I know that last status meeting, he mentioned that there were some features he wanted in there before beta4
David Burns 9:17 PM
@Puja Jagani has done some .Net stuff. If Jim tells us what needs doing we can help
Simon Stewart 9:18 PM
I think it’s probably CDP-over-Grid, and maybe the CDP version stuff
9:18 PM
But, obviously, @jimevans knows waaaay more than I do about that
David Burns 9:18 PM
I need to do the multiple options handling to capabilities work in the python code
9:19 PM
If I had deprecated some of the code in 3.14 it would be Waaaaaaay easier
Simon Stewart 9:20 PM
We can have a discussion about what you’re thinking of breaking later
9:20 PM
It may just be that we do the simple thing, though
As far as I’m concerned, then, the thing we’re waiting for is @jimevans to give us the green light for the .Net stuff being ready for beta4
Titus Fortner 9:21 PM
I did just notice that Ruby hasn’t implemented Full Page screenshot support for Firefox, yet; I’ll get that added today.
And on that vein, I need to create some examples of browser specific features being used with Remote drivers in each language, because I know not everything is working in every binding, yet
Simon Stewart 9:21 PM
What do other people think?
David Burns 9:21 PM
Nothing will break promise
Simon Stewart 9:21 PM
@titusfortner I think we can set “feature parity between bindings” as an rc1 goal
Titus Fortner 9:21 PM
yup, makes sense
9:22 PM
I"ll get the Firefox screenshot thing in before beta4
Simon Stewart 9:22 PM
As long as the broad features are there in beta4 (notably, the CDP-related infrastructure, if not the nicer APIs built on top)
Titus Fortner 9:22 PM
Very excited about how close we are :slightly_smiling_face:
Simon Stewart 9:22 PM
Which neatly brings us on to What do we want in RC1?
Titus Fortner 9:23 PM
ensure feature parity :slightly_smiling_face:
Simon Stewart 9:23 PM
Titus Fortner 9:23 PM
or at least document it
Simon Stewart 9:23 PM
Documentation :slightly_smiling_face:
Titus Fortner 9:23 PM
while we’re here, the JUnit 5 dev doesn’t have any ideas for how to fix the issue:
Comment on #2273 Parallelism value ignored for the fixed strategy
I’m all ears if anyone has a proposal how to resolve this. The only thing I’ve come up with would be to wrap the execution of each test in another, non-ForkJoinPool thread but that would double the number of required threads and have performance implications. https://github.com/junit-team/junit5|junit-team/junit5junit-team/junit5 | May 13th | Added by GitHub
9:24 PM
it’s definitely a JUnit thing, but it’s going to affect our users :disappointed: :disappointed:
Simon Stewart 9:24 PM
Why they don’t just maintain an AtomicInteger of the number of running threads is beyond me
Titus Fortner 9:25 PM
Can you suggest that?
9:25 PM
I am so far out of my depth with threading that I will get in the way more than help
Simon Stewart 9:25 PM
We can get this sorted :slightly_smiling_face:
Titus Fortner 9:26 PM
:thumbsup:
Simon Stewart 9:26 PM
Does anyone have anything else that they want to see in rc1?
9:26 PM
Or, to rephrase, if we ship rc1 and nothing major blows up, what would stop us making the release after that 4.0?
9:28 PM
(I’m going to take silence here to mean that everyone is really busy right now)
Titus Fortner 9:29 PM
Your list looks good to me…
Simon Stewart 9:30 PM
OK.
9:31 PM
So, let’s move on to Selenium IDE
I think that there’s a small core of us who could release the IDE
9:32 PM
But @corevo and DaveH would know the process best
9:33 PM
To recap:
Todd Tarsi 9:33 PM
@simonstewart - I would love to help in any capacity that I can, including reviewing PRs.
Simon Stewart 9:34 PM
That’s great news :slightly_smiling_face:
9:34 PM
Thank you
9:34 PM
Again, it feels like we’re not going to make much progress today on this.
Titus Fortner 9:35 PM PM
I think we need to hear back from former owners to make progress on it
Simon Stewart 9:35 PM
Can I suggest that we set up a call or email chain with @corevo, DaveH, @harsha509 and whoever else is interested to move that forwards?
Titus Fortner 9:35 PM
can we reach out to them not-on-slack since they don’t seem to be paying attention here?
yes, that :slightly_smiling_face:
Simon Stewart 9:35 PM
nods
@harsha509, would you be okay arranging that?
If we can get you email addresses….
Sri Harsha 9:36 PM
I can take inputs from @corevo on how to release and document it.
9:37 PM
Sure @simonstewart
Simon Stewart 9:37 PM
Brilliant. Thank you. I’ll be happy to help move things along if I can
Sri Harsha 9:37 PM
:bow:
Simon Stewart 9:37 PM
@Todd Tarsi I bet it’d be interesting to hear how the electron work was going
Todd Tarsi 9:38 PM
@simonstewart - It will be better with a PR as a point of discussion, so I’ll put one out later tonight.
Simon Stewart 9:38 PM
Oh yeah. Definitely a PR discussion :slightly_smiling_face:
9:39 PM
Alright then, folks. I think we’ve romped through the agenda.
9:39 PM
Is there anything else people would like to talk about?
Titus Fortner 9:39 PM
What is the current status of BiDi?
Luis Correia 9:40 PM
Documentation :slightly_smiling_face:
Titus Fortner 9:40 PM
I think we closed the issue that was listing what we were going to implement, presumably because we’ve implemented the things we deemed essential
Simon Stewart 9:41 PM
Status of Bidi? The w3c spec, or the use cases we planned to support?
Titus Fortner 9:41 PM
the latter
and the former to the extent that it might be what is driving the latter?
Simon Stewart 9:41 PM
@Luis Correia Acknowledged. We’ll talk about docs after the bidi stuff
The w3c spec won’t be finished before we ship 4.0, so let’s set that aside
Titus Fortner 9:42 PM
oh yes, I waited until after we were done talking about betas and RCs to bring this up :slightly_smiling_face:
this is future roadmap things
Simon Stewart 9:42 PM
So, the use cases from the issue were:
9:43 PM
Recording traffic can be done by the same code that does network interception
I think bootstrap scripts are probably the most poorly supported thing right now
9:44 PM
Technically, Java has code for it, but I have zero confidence it’s robust. Or, indeed, that I actually landed it
The w3c spec started with a discussion of use cases too, and there’s a lot of overlap (surprise!)
9:45 PM
I’d love to get script pinning using CDP in place. That’ll exercise bootstrap scripts sufficiently
Titus Fortner 9:46 PM
So maybe I need to better understand how the spec and selenium code are supporting each other. Do we need to make sure the features we are adding are documented in the spec?
(i.e. is one driving the other, or is this like before where geckodriver & w3c drove each other)
Simon Stewart 9:47 PM
The spec is currently putting in place a lot of the groundwork to start doing useful things, so it’s not covering the use cases yet
9:48 PM
I suspect that Selenium 4 utilisation will help steer the spec as we find out the subset of the CDP that’s actually useful for testing and automation
Titus Fortner 9:48 PM
perfect, thanks
Simon Stewart 9:48 PM
It’s something of a chicken-and-egg problem right now.
9:49 PM
Once we ship 4, I’m planning to switch my focus to the spec
Titus Fortner 9:49 PM
always is with specs, right? :slightly_smiling_face:
Simon Stewart 9:49 PM
Always :slightly_smiling_face:
We have 10 minutes left! Shall we move on to Documentation?
Titus Fortner 9:49 PM
@diemol are we moving / have we moved to a different theme?
for docs
Simon Stewart 9:49 PM
@Luis Correia could you please expand on what you meant?
Luis Correia 9:50 PM
about single port grid or documentation?
Simon Stewart 9:51 PM
Documentation, please
Luis Correia 9:52 PM
ok, it is my understanding that current docs are too surgical, explaining one thing but maybe not with full context Specifically in the grid 4 docs
Simon Stewart 9:52 PM
How would you like that to change?
Luis Correia 9:53 PM
in the website there isn’t a section with all available options and switches, one has to delve into code
9:53 PM
note: it’s not a blocker for release but rather a nice to have feature
9:55 PM
this is a good starting link
https://www.selenium.dev/documentation/en/grid/grid_4/
selenium.dev
Grid 4 :: Documentation for Selenium Documentation for Selenium
Simon Stewart 9:55 PM
OK, so a better description than you get from selenium -h?
Titus Fortner 9:55 PM
https://www.selenium.dev/documentation/en/grid/grid_4/configuring_components/config_help/
selenium.dev
Config help :: Documentation for Selenium
Documentation for Selenium
Luis Correia 9:55 PM
I would be happy with that on a webpage
Simon Stewart 9:56 PM
OK. Would you please leave a comment on https://github.com/SeleniumHQ/selenium/issues/8165?
8165 Update user docs with new Selenium 4 features :rocket: Feature Proposal Selenium 4 brings a set of all-new features and https://www.selenium.dev/documentation/en/ needs to be updated to contain the related docs for them. Motivation
It’d be nice to have the following new features covered in the docs: • Relative locators • CDP integration • New Grid 4.0 Example … Labels C-docs, Selenium-4-Beta Comments 2 https://github.com/SeleniumHQ/selenium|SeleniumHQ/seleniumSeleniumHQ/selenium | Apr 7th, 2020 | Added by GitHub
Titus Fortner 9:56 PM
looks like the page I linked there shows the commands but not the output?
Luis Correia 9:56 PM
@titusfortner or even why, that’s proper context
9:57 PM
i will @simonstewart
Titus Fortner 9:57 PM
providing context for it would definitely be useful
Simon Stewart 9:57 PM
Much appreciated. That’s the tracking issue for improving the docs, so adding comments there will be helpful
Titus Fortner 9:58 PM
Or you can PR the changes you think would provide the context; docs are all in a public repo.
I’m struggling a bit with Sauce documentation right now. I’m good at making sure the info is “correct,” but finding I’m not so great on explaining why it matters to people, and that part is important
Simon Stewart 9:59 PM
@titusfortner I guess you’ve seen https://developers.google.com/tech-writing?
Titus Fortner 9:59 PM
It’s like I have “presentation” mode and “documentation” mode and I can’t get them to work together :smile:
Simon Stewart 9:59 PM
Ah yeah. It’s hard to get the narrative right
Titus Fortner 10:00 PM
well, it also helps to have people at Sauce whose actual career is organizing info so people can understand it
10:00
I hadn’t seen the tech-writing page, that looks interesting
Simon Stewart 10:01 PM
Shall we wrap up? I think we covered most of the things we needed to
10:02 PM
The major decision was to wait for @jimevans to give us the green light for shipping beta 4.
I’m totally fine waiting as long as necessary for that, but I also heard @AutomatedTester suggest that maybe @Puja Jagani could help with that
Titus Fortner 10:06 PM
sounds great, thanks @simonstewart!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on May 06, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Simon Stewart 9:01 PM
Alright then. It’s time
9:02
@AutomatedTester, @titusfortner @p0deje, @jimevans, @harsha509, @barancev, @Puja Jagani, and @diemol (plus anyone else who’s interested)
Let’s get the show on the road
9:02 PM
I think we can wait for @diemol to be back for the stats for the past couple of weeks
Any agenda items?
9:03 PM
Diego Molina 9:03 PM
Here, quick meeting with my manager done
David Burns 9:04 PM
Managers are the worst…
Simon Stewart 9:04 PM
hands over meeting reigns to @diemol
Diego Molina 9:04 PM
Stats from previous meeting:
Data taken from this link[https://www.diemol.com/github-repo-stats/seleniumhq_selenium/index.html]
David Burns 9:05 PM
A lot of those are from @Puja Jagani
9:05 PM
she has been busy
Simon Stewart 9:06 PM
She’s been rocking it
Diego Molina 9:06 PM
the issues or the PRs?
9:07
Right, work that we want for the next beta (4)
(I could not contribute that much during the last two weeks :confused:)
9:08 PM
These are items from the last meeting:
Maybe only this one got done? “Unify new Session Queue”
Simon Stewart 9:08 PM
I’d like to add:
David Burns 9:08 PM
Do we have issues/docs on the investigate stuff?
Simon Stewart 9:08 PM
Yeah. We unified the new session queue
9:09 PM
I’ve a PR in the works for the “follow the spec” bit
David Burns 9:09 PM
for the last item about IE… we can allow that to happen but it seems like a major footgun
Diego Molina 9:10 PM
There are issues for the investigation items, and maybe there is a PR from @Puja Jagani solving the “browser driver process cannot be killed” one
I will double check that all items have a GitHub issue, and if not, I will create one
David Burns 9:12 PM
thank you
Diego Molina 9:14 PM
For language bindings we had this:
Language bindings
Saksham Gupta 9:14 PM
Hello all, been a year since I started my internship. Thought I’ll drop by to say hi.
Simon Stewart 9:15 PM
Java should be doing se:cdpVersion now
David Burns 9:15 PM
@harsha509 do you need a hand with the cdpVersion stuff for JS?
Simon Stewart 9:16 PM
I think we need to review what’s in the python bindings that’s not elsewhere: my impression is that there’s been a few things added
David Burns 9:17 PM
@simonstewart only 1 thing which is mobile options
Simon Stewart 9:17 PM
kk
Sri Harsha 9:17 PM
Yes @AutomatedTester, i have been busy with paid work, didnt got a chance to look into it
Diego Molina 9:17 PM
what are mobile options?
David Burns 9:17 PM
@diemol the ability to set android* config better
you could do it before but I made it a little nicer after a request from whimboo
9:18 PM
I actually want to change it to support iOS better
Diego Molina 9:18 PM
Nice!
David Burns 9:19 PM
but it means you can create a normal chrome/firefox options and pass it through to the driver to connect to said browser on android :+1: 1
9:20 PM
you could before if you knew the magic for it
Diego Molina 9:20 PM
Something else we need to figure out is how to release the IDE, given that @Todd Tarsi is helping us and contributing to it
9:20 PM
does anyone know about it?
Simon Stewart 9:20 PM
Who did the last release? @corevo, I thought
9:20 PM
?
David Burns 9:21 PM
I think it was him. I will email him and Dave for guidance here
Diego Molina 9:21 PM
great, thank you
and I have one last thing from my side
I have spoken to @Puja Jagani and asked her if she is interested in becoming a committer Therefore, I have created this PR https://github.com/SeleniumHQ/seleniumhq.github.io/pull/679 Folks, please go an check it out
I think she has done so much great work and without her we would not have moved at the speed we are currently moving :slightly_smiling_face:
Puja Jagani
Thank you David, Diego and Simon for the constant support and help :relaxed: Very happy working with the Selenium TLC folks!
Simon Stewart 9:25 PM
I’m onboard with this
Diego Molina 9:25 PM
(there is probably a shorter way to say what I said, but my English is no bueno sometimes)
David Burns 9:26 PM
+1 but I am biased :smile:
Diego Molina 9:26 PM
We simply need PR approvals :slightly_smiling_face:
Titus Fortner 9:27 PM
Sorry, I’m showing up late. :slightly_smiling_face:
Did we get the blockers for beta 4?
Have a couple bug fixes that would be nice to get released
Simon Stewart 9:27 PM
@diemol’s in charge here
Diego Molina 9:28 PM
No @titusfortner, sorry. I think we need to improve with PR reviews in the next days so we can get closer to beta 4
9:28 PM
I believe you are talking about the JUnit issue?
Sri Harsha 9:29 PM
i will update few things in ide stuff, electron version bump and updating rules_nodejs
Titus Fortner 9:29 PM
No, that’s a different issue :slightly_smiling_face:
Diego Molina 9:30 PM
Which issues did you have in time?
9:30 PM
in mind*
Titus Fortner 9:32 PM
some fixes in Ruby code
9:32 PM
just wanted to get stuff out there sooner if that’s an option
Simon Stewart 9:33 PM
We’ve yet to agree when we want to ship beta4, so there’s probably time
9:34 PM
Unless you want the fixes to be blockers
Titus Fortner 9:35 PM
I mean, Alex changed something that was blocking someone and I’m wondering when we can get it released to him :smile:
Simon Stewart 9:36 PM
Ah! So you want the release sooner :slightly_smiling_face:
Titus Fortner 9:36 PM
9:36 PM
apparently there is a project that refuses to look at firstMatch values
Sri Harsha 9:36 PM
For JS i want to:
Simon Stewart 9:37 PM
@titusfortner I have no idea how a project not following the spec is a reason for us to ship sooner, but I assume there’s context I’m missing….
David Burns 9:37 PM
is this appium?
Titus Fortner 9:40 PM
A Watir user is using aerokube/ggr
Ruby code defaults to F/M, but the project doesn’t accept it (https://github.com/aerokube/ggr/issues/314)
He asked the devs and their private reply: Ggr does not support “sophisticated” selenium “match” rules and we do not plan to implement that, because it is ambiguous
So Ruby changed default implementation to be A/M since it *shouldn’t matter but apparently does
just trying to help the user
Simon Stewart 9:41 PM
It’s the exact opposite of ambiguous
Titus Fortner 9:41 PM
oh, I know
9:41 PM
if this had been a public response i’d have been all over it
Simon Stewart 9:41 PM
WE should probably have a chat with the Aerokube folks
9:42 PM
Because Se4 will break them a lot
Titus Fortner 9:42 PM
The suggestion I got is either to try their new product: aerokube.com/moon or do not use ggr and go with selenium.
Simon Stewart 9:43 PM
So moon supports the w3c payload but not ggr?
Titus Fortner 9:44 PM
that’s what it sounds like
David Burns 9:44 PM
Aerokube… the group that bad mouths selenium… that aerokube?
Titus Fortner 9:44 PM
I don’t know what ggr vs moon is, didn’t get too deep into it
Simon Stewart 9:45 PM
Moon is their paid-for product.
Titus Fortner 9:45 PM
ah of course it is
you want fancy, you pay the money!
s/fancy/sophisticated
Simon Stewart 9:45 PM
A perfectly valid business model
David Burns 9:45 PM
In which they they tell everyone that selenium grid is useless
9:46 PM
I’m happy to help those that don’t bad mouth us
Difference of opinion is also fine
9:47 PM
But… *channels his inner @jimevans *
Titus Fortner 9:47 PM
I don’t remember off hand which bindings default to A/M and which to F/M
9:47 PM
I was going to run some tests
Diego Molina 9:50 PM
I think we should not hurry for a project that does not support standards
Titus Fortner 9:51 PM
I don’t care about them
9:51 PM
I care about a user who needs to change because of them
Diego Molina 9:51 PM
Anyway, I think those were all the topics we had :slightly_smiling_face:
Diagnosing problems when the Selenium server isn’t working has never been easy. With Selenium 4, we have integrated OpenTelemetry to help you troubleshoot issues, optimize performance, and provide visibility into the system. By making the Selenium server observable, we are putting more power into your hands.
Selenium server enables distributed testing. Instead of running the browsers for tests locally, the tests use a remote browser driver that points to a server. The server makes “smart” decisions to run tests on different remote servers. Every such remote server is capable of hosting different types of browsers and browser versions.
Selenium 3 uses Hub as the coordinator. It receives new session requests and directs them to the appropriate Node. The Node is the remote end where the browser itself runs.
Selenium 4 extends this to provide users with a way to set up a full-blown distributed system. Essentially, Selenium 4 splits the Hub into different components with additional enhancements. However, the Node’s role remains the same. To ensure the backward compatibility and simplicity of setting up Grid, standalone and hub-node mode are also available in the new Selenium server.
Now picture running a full-blown distributed Selenium Grid with hundreds of Nodes with different browsers and browser versions. Testing at scale in such an infrastructure will involve large volumes of requests. How can one keep track of these requests? Enter Selenium Observability!
Selenium uses OpenTelemetry to instrument tracing and event logs. Tracing keeps track of a request’s lifecycle. As a request moves through the distributed system, the trace of the request will contain all the information of its crucial operations performed along the way. Such operations are known as spans. A span can record timed logs called events, which ideally encapsulate the current state of the system. These are event logs.
By default, the Selenium server enables tracing. Selenium server can run in different modes:
Tracing and event logs are available for all the modes. The simplest way to see traces is in the form of console logs. By default, the Selenium server prints logs at the INFO level and above. To pass a logging level of choice while running a Selenium Grid use the log-level flag. Setting the log-level to FINE will display traces and event logs as console logs.
For a large scale system, consuming traces as logs might not be efficient. Visualizing and querying traces will quickly help troubleshoot a request failure easily. Jaeger seamlessly integrates with OpenTelemetry to provide a rich experience of querying, visualizing and collecting request traces.
Run java -jar selenium-server-<selenium-version>.jar info tracing
.
It provides detailed and updated instructions to set up Jaeger with the Selenium server. Visualizing the traces makes it easy to interpret a trace and understand request flow. Now Grid users can effortlessly trace a request, drill down into an error or query them to observe what is happening.
Refer to Selenium Observability for details.
The Java client binding supports tracing. Full-stack tracing allows tracing a request from the client to the server and back. Though the client is a single component, the client trace will contain spans that help build the request. It is easier to locate a client-side problem and fix the test if needed.
We already saw how the server supports tracing and how to leverage it. For the client-side, add the Opentelemetry dependency to your project setup and add the necessary system properties to export the traces to Jaeger. Refer to RemoteWebdriver client for detailed instructions.
The key to fixing a problem lies in knowing the error. For a known error situation, the event logs have you covered. It provides detailed error information and stack traces. Query the collected traces for a time range by the error code to identify the frequency of the error. It will help determine if the error is transient or not and accordingly take action.
Observe the request latency to identify potential bottlenecks. Each trace will also contain time taken by each span. The issue could be in the underlying infrastructure setup, the network latency, or the code itself. Irrespective of the cause, it is easier to identify the problem area.
Observability is slowly becoming a must-have property of a system. Selenium is now observable! Go ahead try it out. Let us know if you find anything that requires improvement on our end.
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on April 22, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:02 PM
pinging @simonstewart @AutomatedTester @harsha509 @Puja Jagani @jimevans @barancev @manoj9788 @mmerrell @titusfortner @p0deje
Simon Stewart 9:02 PM
I’m going to be at SauceCon
9:02 PM
Things I want for beta 4:
Diego Molina 9:02 PM
and whoever else is around :slightly_smiling_face:
9:03 PM
General project statistics
Simon Stewart 9:03 PM
Things I want for beta 4:
Diego Molina 9:06 PM
Next topic:
Language bindings
Simon Stewart 9:06 PM
The “unify new session queue” is mostly done, I think
9:07 pm
(Famous last words)
Diego Molina 9:07 PM
That is the PR you sent, which we will work with @Puja Jagani, I believe
Luke Hill 9:07 PM
Someone (In fact a couple), were asking me about the alphas / betas. And they were asking more along the lines of are we expecting a whole host of them like we had for v3.
9:08 PM
I gave them the whole spiel - We don’t do release timelines e.t.c. But figured I’d ask here if anyone has a finger in air idea.
Diego Molina 9:08 PM
For the Grid work, I am taking the items related to “investigate”
9:09 PM
But I wanted to ask folks here, what do you think about “More than 1 IE session per Node? https://github.com/SeleniumHQ/selenium/issues/9388”
Titus Fortner 9:10 PM
@luke tell them it doesn’t matter and if they are only using the bindings they should already have updated. The only stuff really being worked on at this point is grid functionality and adding in the various new features from w3c spec, etc There is no technological advantage to sticking with 3.x at this point
Luke Hill 9:10 PM
That went against all advice and articles published that explicitly stated “Do not use more than 1 IE session per node” @diemol
David Burns 9:10 PM
re: se:cdpVersion, it’s easy to add but I noticed we never use the versions, we seem to use the latest one
Diego Molina 9:10 PM
Some people are complaining they cannot run more than one test per Node, which we recommend against Because they have been able to do it. The code change is small, and I believe we should let them, with the caveat of “you are on your own here”
Luke Hill 9:11 PM
Do we know when/where this restriction came in? With an accompanying PR?
Diego Molina 9:11 PM
IE restriction? Since the moment zero Grid 4 was built
Simon Stewart 9:12 PM
@AutomatedTester the java bindings should be using the version
David Burns 9:12 PM
@simonstewart sorry, meant JS
JS bindings only use latest…
David Burns 9:12 PM
@simonstewart sorry, meant JS
9:13 PM
JS bindings only use latest…
Diego Molina 9:14 PM
@AutomatedTester I believe it has not been implemented in C# and JS (I need to double check Java)
David Burns 9:14 PM
JS doesn’t need it… yet without a bit of rearchitecting
I, or @Puja Jagani since she has been dabbling in .NET, can do the c# ones
or @jimevans obvs
Diego Molina 9:15 PM
I believe the idea is to use the “right” CDP version depending on the browser version, so it’d be nice if JS has it
David Burns 9:16 PM
maybe @harsha509 has time to look into it
Sri Harsha 9:17 PM
it requires rewriting the CDP in JS. i will look into it then.
Diego Molina 9:17 PM
that’d be amazing
cool, so I believe we need to work a bit on the pending items and see where we are in two weeks :slightly_smiling_face:
Titus Fortner 9:18 PM
From a bugs standpoint, #9359 is an absolute blocker for Sauce users to move to Selenium 4, but @Puja Jagani is helping confirm it.
Would be nice to at least know what is going on before next release
Diego Molina 9:20 PM
I think we have enough time to figure that one out
Simon Stewart 9:20 PM
The reproducible test case is helpful
Titus Fortner 9:20 PM
yeah, should have done that from the start
Diego Molina 9:20 PM
I wonder if someone asked @titusfortner for a reproducible test case :smile:
Titus Fortner 9:21 PM
tbf I did put exactly what needed to go into the POM
9:21 PM
I just didn’t create a whole project that can be cloned to see the issue
Diego Molina 9:21 PM
anyway, we could move to the last topic for today, the IDE
9:21 PM
Selenium IDE
Sri Harsha 9:22 PM
By beta 4, i will be resolving JS api docs too. May be i can pass it to @diemol for review and upload
Diego Molina 9:22 PM
What is needed for a release*
Diego Molina 9:23 PM
@Todd Tarsi is here and they want to contribute, so it would be nice to give them a hand
David Burns 9:23 PM
if @corevo or @tourdedave have documented the release process I think I have some of the keys to do it
Diego Molina 9:23 PM
I can check if it is documented, else reach out to them
Todd Tarsi 9:23 PM
Hi all, yep if I can help in any way, please let me. I’ve been doing selenium ide stuff since it was UI with zanarkand (is that the right name?) back in the day
Diego Molina 9:24 PM
We need the keys for the 3 stores, right? Edge, Chrome and Firefox
9:25 PM
we should also update the docs to mention it is available in Edge
Todd Tarsi 9:27 PM
I can PR simple docs changes if we want.
Diego Molina 9:27 PM
cool
so we will check what is needed to properly test and release the IDE, and we will post here in #selenium-tlc
thanks for showing interest, @Todd Tarsi
ok, I think that is all for today, right?
does anyone have an extra topic?
seems not, thank you everyone!
(and thanks @harsha509 for publishing the notes to our blog :slightly_smiling_face:)
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on April 08, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 8:59 PM
Ok, proposed agenda is:
please feel free to add any other topics
pinging @titusfortner @manoj9788 @mmerrell @simonstewart @barancev @Puja Jagani @AutomatedTester @harsha509 @jimevans
Alright, let’s start with today’s public meeting :slightly_smiling_face:
9:02 PM
General project statistics
Marcus Merrell 9:03 PM
no news to report from me–still working on the CoC with Karen, and working on either booking the Chicago venue for a 2022 conference, or getting our $40,000 back
Diego Molina 9:04 PM
thanks for sharing @mmerrell
Simon Stewart 9:04 PM
Presumably we’re looking at late 2022 for the in-person conference?
Diego Molina 9:05 PM
I hope so
are there any thoughts around a virtual conference this year?
Simon Stewart 9:06 PM
I’m lukewarm about virtual conferences. It’s hard to sit and watch YouTube videos all day
Diego Molina 9:06 PM
me too, but as a project we should consider that alternative
David Burns 9:06 PM
having just done one for work there is a “we’ve had enough” vibe going
9:07 PM
it was a success but I don’t think we could have done it later this year
Simon Stewart 9:07 PM
I’d love to do some short videos on topics, though
Things like relative locators, shadow DOM, CDP, etc
And we can do a “q&a” one with committers and a host
We should ask folks if they’d like to do something, and then maybe post one or two a month?
Diego Molina 9:08 PM right, a mini conference would be nice
Simon Stewart 9:08 PM
Provided we pay for someone to help make the videos and edit them
Titus Fortner 9:08 PM
less “talks” and more “video tutorials with Q&A?” :)
Diego Molina 9:08 PM
perhaps one day of workshops and one day of short talks
Simon Stewart 9:09 PM
Workshops are a really good thing to do
David Burns 9:09 PM
I would like to think on it more before committing either way
Simon Stewart 9:09 PM
Not even sure about “one day of short talks”. Just posting things regularly on the YT channel
Titus Fortner 9:09 PM
I really like it when there is a “time” that a video is shown, and the author can chat with people about it in whatever room, and then answer questions at the end
9:10 PM
then everything can be posted in whatever channel for people to watch
Simon Stewart 9:10 PM
I can see that
Diego Molina 9:10 PM
well, there we have a whole topic to think about :slightly_smiling_face:
Simon Stewart 9:10 PM
Ha! :slightly_smiling_face:
Titus Fortner 9:10 PM
but I do like the idea of a series of shorts on different pertinent selenium topics
9:11 PM
less “why testing is like a toaster oven” and more practical on how to get the most out of new Selenium 4, etc :-D
Simon Stewart 9:11 PM
Right
Diego Molina 9:12 PM
ok, I am a bit short of time today, so I suggest to go back to the agenda and if there is time, we can circle back to ideas about a “conference”
Titus Fortner 9:12 PM
:thumbsup:
Diego Molina 9:12 PM
Next topic:
I have a short list of things I know they were done, so I will paste it here
Simon Stewart 9:12 PM
Been quiet from me, but I have landed the bits to plumb through se:cdpVersion and have started on a unified New Session Queue
Diego Molina 9:13 PM
(there was a bug when matching Windows as a platform)
9:14 PM
yeah, if you try the Grid right now, CDP for Firefox should work also (but there are some CI tests failing for Firefox)
I also added noVNC to the docker containers, that bring us closer to have the live view in the Grid UI
Simon Stewart 9:15 PM
That’s very cool
Diego Molina 9:15 PM
Ok, so now having said what we have done during the last two weeks, we can now talk about what is left for beta 3:
Pending work that needs to be done for the third Beta?
I will paste the things that come from the previous meeting, but please add/remove as you wish
Simon Stewart 9:16 PM
Thank you
Diego Molina 9:16 PM
Server changes:
Things left in Java, Python, JS, Ruby, C#?
Marcus Merrell 9:16 PM
(just to close out the 2022 conference idea–yes, Fall of 2022 in Chicago)
Simon Stewart 9:16 PM
Adding: unify the new session queue
Diego Molina 9:18 PM
We had this comment from the last meeting:
Here’s the plan, then. We’ll ship beta3 when two of these conditions are met:
is this still valid? what do you all think?
Simon Stewart 9:18 PM
Time has elapsed. I’m not convinced we’re using se:cdpVersion properly on the local end yet
Titus Fortner 9:19 PM
looks like Java is the only one using it
Simon Stewart 9:19 PM
@jimevans can tell us whether the .Net bindings work
David Burns 9:19 PM
I will look at the Python/JS stuff for that tomorrow
Titus Fortner 9:20 PM
There are several Ruby bugs that we fixed, so I’m for releasing beta 3 even without cdpversion implemented
9:21 PM
I would like to get v90 & v91 devtools support added
Diego Molina 9:21 PM
Grid is now returning se:cdpVersion properly, and the Java bindings (when running locally) are also returning it properly
Titus Fortner 9:21 PM
or at least v90
David Burns 9:21 PM
that seems simple then…
Diego Molina 9:21 PM
but I wonder if the other bindings also create and manage se:cdpVersion when running locally (not over Grid)
Titus Fortner 9:22 PM
wait is Firefox using CDP 85 or 86?
Simon Stewart 9:22 PM
@titusfortner I can help you land the CDP v90 stuff
Diego Molina 9:22 PM
86
Titus Fortner 9:23 PM
I think I followed the guid and have the pdl files for the latest v90
Simon Stewart 9:23 PM
@diemol I’m not sure the java bindings use se:cdpVersion properly
David Burns 9:23 PM
firefox is 85 unless they changed it
Titus Fortner 9:23 PM
Well, if we aren’t hard coding it to 85, then I need to figure out how we want to approach that going forward :slightly_smiling_face:
I just see that trunk has FirefoxDriver set to use 86
(in Java)
which I didn’t think was correct
David Burns 9:24 PM
Java is wrong then
Simon Stewart 9:24 PM
Easy fix
David Burns 9:24 PM
r-
9:24
:stuck_out_tongue:
Diego Molina 9:25 PM
Seems we need to create a GitHub issue to track that
I’ll do that now
Simon Stewart 9:26 PM
Thanks
Jim Evans 9:27 PM
.NET still doesn’t proxy CDP across RemoteWebDriver yet.
is jumping through corporate IT/security/legal hoops right now.
Titus Fortner 9:29 PM
that sounds joyful
Diego Molina 9:30 PM
ok, created this to track it https://github.com/SeleniumHQ/selenium/issues/9365
please feel free to add more details
(if needed)
9:32 PM
So, IMO, we should have se:cdpVersion working and all bindings doing CDP over Grid before beta 3, right?
what do you think?
Simon Stewart 9:32 PM
I’m letting @jimevans call it
Jim Evans 9:33 PM
let’s not hold up beta3 for that. if i get to it before then, fine, but i’m swamped right now.
Titus Fortner 9:33 PM
I definitely don’t think we need cdpVersion
9:34 PM
doing CDP over grid doesn’t require that per se
Diego Molina 9:34 PM
no, it does not, they are two separate things
Titus Fortner 9:34 PM
Does Python & JS have CDP over grid working?
Simon Stewart 9:34 PM
I’d like to get the java bindings consuming se:cdpVersion properly.
Titus Fortner 9:35 PM
can we save that for beta4?
David Burns 9:35 PM
replied to a thread: Does Python & JS have CDP over grid working?
It should do
Diego Molina 9:35 PM
I know it would be ideal to get a beta 3 soon, but if we need to wait to have all bindings working with CDP, I am ok with that
Titus Fortner 9:35 PM
I generally don’t like putting off a release until Java gets something working, because that just means we wait for everyone else to implement it or Java is off from the rest of us. :smile:
Diego Molina 9:36 PM
I have seen issues asking “can we have in JS what it is already done in Java”, and similar
Titus Fortner 9:36 PM
Like I said, I have several bug fixes that would be nice to get into people’s hands sooner
I guess I can always do a beta 2.1 for ruby, but…
Simon Stewart 9:36 PM
Let’s aim for next Tuesday for beta 3
Diego Molina 9:37 PM
I am also ok with that
but I don’t want to reach RC without some degree of feature parity between bindings
even if it takes longer
Jim Evans 9:38 PM
i get my second vaccine dose on tuesday, so it’ll be in the afternoon
9:38 PM
(US eastern time)
Titus Fortner 9:38 PM
woo hoo!
Diego Molina 9:38 PM
oh, that’s amazing!
Simon Stewart 9:38 PM
RC should have feature parity
I’d like that one out for a few days, and then we ship 4.0.0
Titus Fortner 9:39 PM
oh, while we’re here, I think Java & .NET are the only ones who have implemented these? https://w3c.github.io/webdriver/#get-computed-role
9:40 PM
These new endpoints sneak up on me
Simon Stewart 9:40 PM
There are a few. The Shadow DOM ones are new as well
Titus Fortner 9:41 PM
oh no, python & java
Simon Stewart 9:41 PM
I think @AutomatedTester has snuck in a broader API than the rest of us since he actually reads specs
Titus Fortner 9:41 PM
sneaky
Simon Stewart 9:41 PM
Clever lad
David Burns 9:41 PM
none of the shadow dom stuff is done
9:42 PM
but I am adding it to Firefox
Sri Harsha 9:42 PM
JS bindings have it too, only left with shadow-dom
Jim Evans 9:42 PM
@titusfortner.NET does the get computed ones too
David Burns 9:42 PM
If you watched todays twitch you would have seen why… I am not sure of the API for things not Java/.NET
Titus Fortner 9:43 PM
so what everyone is saying is that it’s just Ruby slacking
Diego Molina 9:43 PM
ok, so we’ll aim beta 3 for next Tuesday :slightly_smiling_face:
David Burns 9:43 PM
@titusfortner not ruby… whistles :stuck_out_tongue_winking_eye:
Diego Molina 9:43 PM
last topic is:
9:44 PM
there are a few ones that could be an “easy” merge and ideally they do not need a lot of time for a review
I also see @Puja Jagani now contributing to the C# bindings, which is great!
I’ll list the PRs here:
C#
Python
David Burns
done
Diego Molina
thank you!
Diego Molina 9:47 PM
Java:
9:48 PM
in case you have some spare time, @AutomatedTester @jimevans @simonstewart
that’s all I had in the agenda :slightly_smiling_face:
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on March 25, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:54 PM
Agenda for the public meeting:
Please feel free to add any other topics
pinging @jimevans @barancev @simonstewart @AutomatedTester @titusfortner @harsha509 @luke @Puja Jagani and anyone else who wants to join
Simon Stewart 9:56 PM
Thanks for the ping :slightly_smiling_face:
Diego Molina 9:58 PM
forgot to ping @manoj9788 and @mmerrell
Marcus Merrell 10:00 PM
I haven’t heard back about the CoC work - last we left it, Karen was reaching out to Larissa
David Burns 10:00 PM
I will message Larissa now to see if that happened
Marcus Merrell 10:01 PM
thanks
10:01
I can make contact with her too, if you want to cut yourself out as the middle man I might be able to speed things up
around the conference, it sounds like the Holiday Inn in Chicago is undergoing an ownership change, and hasn’t gotten back to us about postponing to 2022 that’s as of last week
David Burns 10:02 PM
I’ve messaged her in the Mozilla Alumni slack
Marcus Merrell 10:03 PM
ok, thanks
Diego Molina 10:03 PM
Sounds good, so we covered one topic already :slightly_smiling_face:
So… General project statistics
Simon Stewart 10:04 PM
That’s amazing work, folks
Diego Molina 10:04 PM
We are doing pretty well there, I went through many issues and asked if they are still valid. Depending on their reply we can close around 20 more in 2-3 weeks.
Most of the open issues are either feature requests, for the JS and C# bindings Perhaps we need to search for folks to give us a hand there
Simon Stewart 10:06 PM
We could absolutely do with more committers.
Diego Molina 10:07 PM
I will look for folks who have frameworks built on top of Selenium and see if they have time to give us a hand
Simon Stewart 10:08 PM
That’s a great idea
Diego Molina 10:08 PM
I’ve seen this one called Watir, maybe they can help us
Titus Fortner 10:09 PM
They have a slack channel I can ask
Diego Molina 10:09 PM
The original idea is from Titus actually :slightly_smiling_face:
Titus Fortner 10:09 PM
I mean, I cajoled Thomas from Capybara into helping :-D
we were down to one ruby labeled issue. This one we need some kind of decision on: https://github.com/SeleniumHQ/selenium/issues/8179
maybe it’s a wontfix and can be closed, or we can figure out the right thing and knock out the changes
Simon Stewart 10:11 PM
Send Keys in actions is really meant for individual key presses. But I guess we could decompose a more complicated set of inputs to individual key presses and releases
Diego Molina 10:14 PM
Would you like to dig deeper into the issue right now, @titusfortner?
Titus Fortner 10:14 PM
I was generally looking at the needs-discussion ones: https://github.com/SeleniumHQ/selenium/labels/A-needs%20decision
if we need a discussion to figure out what is the right thing, this seems like a good forum for that if we need more info we can push it back til next meeting, etc
Diego Molina 10:15 PM
Makes sense, I can definitely go over those issues and put them in the agenda for the next one, good idea
Titus Fortner 10:15 PM
but no, I don’t need anything specific from that one
right now just wanted to raise it since we haven’t discussed it before :)
if and when we get guidance I/others can implement it, but need to know what to implement :-D or I’ll make the Watir dev do it
Diego Molina 10:18 PM
ok, next topic
Things left in Java, Python, JS, Ruby, C#?
Anything else on the client side?
Simon Stewart 10:19 PM
I have local diffs with se:cdpVersion wired up properly in Firefox and Chromium-based browsers It’s a little funky, and I’d like a test around it before doing much more
Titus Fortner 10:20 PM
We have cdpVersion hard coded for Firefox and are getting browser version to automatically serve the right version to Chrome/Edge the endpoint would make a couple things easier :)
Simon Stewart 10:21 PM
I’m making the browsers return the cdp version and endpoint in the capabilities
se:cdpVersion and se:cdp respectively
Titus Fortner 10:21 PM
oh yes, capabilities not endpoint, I knew what I meant to say in my brain ;-)
Simon Stewart 10:22 PM
Ha! :slightly_smiling_face:
Diego Molina 10:23 PM
Ok now, Server side:
this is what I have in my list, not sure if there is anything more
Simon Stewart 10:25 PM
We should already be sending the CDP url for the Grid in Capabilities
And I’ve got the CDP url for Firefox in my local patches
Diego Molina 10:25 PM
ah, that is true
scratching that
Simon Stewart 10:26 PM
Hurrah! One step closer :slightly_smiling_face:
Diego Molina 10:27 PM
by looking at the download numbers and issues created after beta 2, which is not a lot… what is our overall feeling about beta 3?
let’s say, when most of features and bugfixes are done we release it or do we want to wait a bit more for feedback?
David Burns 10:28 PM
I think do the bug fixes and release
Diego Molina 10:28 PM
+1 to that
David Burns 10:28 PM
the “closer” we are to a full release the more our pool will increase
a “better” question… what do we need to get to a RC?
Jim Evans 10:29 PM
.NET doesn’t do CDP over grid right now. a refactor is required to make that possible. i have it in progress, but it’s not ready to get committe.
David Burns 10:29 PM
so we need ^ to get to RC what else?
Simon Stewart 10:29 PM
Oh. Yeah. RC backwards compat
David Burns 10:30 PM
I mean harder to get to points but wont stop beta releases
Simon Stewart 10:30 PM
I’d also like to properly clean up the java client code to strip out JWP support
David Burns 10:30 PM
and RC I mean release candidate
Simon Stewart 10:30 PM
But I think that’s going to be a hard thing to do
Diego Molina 10:30 PM
Simon using every chance to ship RC into Selenium 4 :smile: New
Simon Stewart 10:30 PM
We can do an RC once we think we’ve got all the features done
I suspect beta 3 may be our last beta, if @jimevans gets the time and support he needs for CDP over Grid
Diego Molina 10:32 PM
I am getting a new Windows machine, in part to see how I can help with C#, so expect questions @jimevans :slightly_smiling_face:
Simon Stewart 10:32 PM
Amazing! :slightly_smiling_face:
Jim Evans 10:33 PM
@diemol happy to collaborate.
Diego Molina 10:33 PM
I believe we covered all topics, unless someone has anything else?
Michael Mintz 10:34 PM
Full official release of Selenium 4 by year’s end?
Simon Stewart 10:34 PM
Even sooner
When shall we aim to ship beta3?
Titus Fortner 10:35 PM
I’m waiting for Simon to decide he has to rewrite the Java HTTP Client before we ship Se 4 ;-)
David Burns 10:35 PM
not next week as I am away but the week after maybe?
Diego Molina 10:37 PM
2-3 weeks from now would be realistic, I think
Simon Stewart 10:37 PM
Here’s the plan, then. We’ll ship beta3 when two of these conditions are met:
Sound good?
Diego Molina 10:38 PM
Sounds good to me
alright, that sounds like a wrap for today’s meeting… however, if anyone has a comment about what we discussed today, feel free to comment it here at any time
Titus Fortner 10:43 PM
Thanks @diemol!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on March 11, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:59 PM
Hopefully it will be a brief one :slightly_smiling_face: pinging folks for the public project meeting… @AutomatedTester @harsha509 @titusfortner @mmerrell @jimevans @simonstewart @barancev @luke
10:01
Agenda for today:
if you have any more topics, please feel free to add them
Titus Fortner 10:02 PM
:wave:
Sri Harsha 10:02 PM
:wave:
Diego Molina 10:03 PM
ok, let’s start slowly while people join… first topic is:
Previous meeting: 234 open issues, 32 open PRs Current: 202, 32 PRs
10:04
Again, really great work lowering the number of open issues!
Diego Molina 10:05 PM
What I see in the open issues, every now and then, is a few feature requests.
I think it’d be helpful to give some feedback on them at some point
Titus Fortner 10:05 PM
I need to remember not to add PRs until after the meeting :)
Diego Molina 10:06 PM
for now, I am closing a few feature requests because they are not aligned at all with Selenium or because no one has commented in over 1.5 years
10:07
ok, let’s move to the next topic Anything new to report from the last PLC/SFC call?
10:08
@mmerrell @barancev @simonstewart @manoj9788 @jimevans
Simon Stewart 10:08 PM
Nothing major. @mmerrell was going to chat with the SFC about the Coc
Diego Molina 10:08 PM
perfect, that was the next topic, CoC :slightly_smiling_face:
do we know what we can do to speed the process a bit? We had an incident in the past few days where a CoC would be helpful https://groups.google.com/g/selenium-users/c/bpeUO9vAa2A
10:10
Could we add the https://www.contributor-covenant.org/ as a start and then iterate on it when the SFC has time?
Marcus Merrell 10:10 PM
that chat happened, and Karen is supposed to reach out to the contractor - I haven’t pinged her in a week, but I can do that
Diego Molina 10:11 PM
thank you, @mmerrell!
David Burns 10:11 PM
I think we can just copy what Sage did from their repos
Diego Molina 10:11 PM
that is also a good idea to have a place to start
David Burns 10:11 PM
yea
10:11
and I think we can have the odd hour from Sage to process it since they work for the SFC now
Diego Molina 10:12 PM
I forgot about that, I’d say we can do that
10:13
what do the other folks think?
Simon Stewart 10:13 PM
I’m okay with that
Marcus Merrell 10:14 PM
I’m fine with it… I simply can’t believe it’s been a year
David Burns 10:16 PM
tbf… I could have pushed harder but since I am with ${employer} that can be hard to find time
Marcus Merrell 10:16 PM
I’m in the same boat, but it’s unreasonable that we have to push this hard as far as I know, we’re a top revenue driver for the SFC, and asking a lawyer to do an hour of lawyering does not seem unreasonable
but we aren’t in a position to make a big change here, so I’ll keep pressing where I can
Diego Molina 10:18 PM
absolutely, at least it feels that we can have a CoC soon by following this path
do you still have the docs Sage gave us, @AutomatedTester?
Marcus Merrell 10:19 PM
if we get that, do we still need to go through the SFC and everything?
David Burns 10:19 PM
I am sure I do
Diego Molina 10:19 PM
I think we still need an expert on the field to help us refine the edges so we are sure we have something good in place
Marcus Merrell 10:19 PM
ok, good
10:20
I just pinged KS
David Burns 10:20 PM
at worst I can take Sage’s repos and just cobble something together
Diego Molina 10:20 PM
perfect, that’d be great
ok, perhaps we can move to the next topic?
Titus Fortner 10:24 PM
we’re as good on grid as we’re going to get without changing the underlying http client, right?
Diego Molina 10:24 PM
ok, so this is what I have about that: Server changes:
Things left in Java, Python, JS, Ruby, C#?
yes, about the http client, I’d say so, but we will know more after people use beta 2
Titus Fortner 10:25 PM
is there a reason we can’t release 2 right away and do the rest for 3?
there are a few things in the Ruby code I want to be able to start using
I’m assuming there have been enough improvements elsewhere to justify a new release?
Would be nice to have more smaller releases so long as code/tests are in a good shape
Diego Molina 10:27 PM
I also have the feeling that the major issue was the Grid memory usage, which we adjusted by having a single http client instance everything else seems to be small adjustments, some could happen for beta 2 and the rest for beta 3
Simon Stewart 10:27 PM
I think so
I’m fine with no getting the se:cdpVersion stuff in before we push the next beta
10:28
Also on my list before 4.0 is getting script pinning using CDP up and running
That feels somewhat gnarly
Diego Molina 10:30 PM
sounds good, so maybe let’s sync during the next days to see when we can release beta 2 (as in, when people are around to give their input as well)
David Burns 10:30 PM
It sounds like there is nothing left to do…
Diego Molina 10:30 PM
we need to fix the javadocs
David Burns 10:31 PM
yes!
Diego Molina 10:31 PM
(maybe that is the most important issue for now :slightly_smiling_face:)
David Burns 10:32 PM
definitely the most important issue
Diego Molina 10:33 PM
ok, I think that was the meeting for today, do we have anything else we’d like to discuss?
David Burns 10:33 PM
nope
Sri Harsha 10:33 PM
we need to update JS doc too
https://www.selenium.dev/selenium/docs/api/javascript/index.html
Diego Molina 10:34 PM
true, while checking old issues, there are 3-4 we could close by updating the docs
ok, so let’s wrap today’s meeting with that, thank you everyone!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on February 25, 2021,5:30 PM CET. (Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:54 PM
@titusfortner @barancev @harsha509 @luke @jimevans @simonstewart
Luke Hill 9:54 PM
Yip. I’m here if needed.
Diego Molina 9:55 PM
The only topic I have today, to make it a short meeting, is: “what is needed for beta 2” Feel free to add/propose any other topics
Luke Hill 9:59 PM
Alongside that, do we have a rough idea of what would enable us to release a 4.0.0 proper (i.e. what milestones we need to hit)
Diego Molina 10:01 PM
Let’s wait a few minutes to see if we have enough people to start the meeting
Titus Fortner 10:04 PM
I have a couple minor things I want to do before beta2, but the sooner the better for me :)
Simon Stewart 10:04 PM
I’m in a planning meeting, but I’ll follow along slowly
Titus Fortner 10:05 PM
(Element#dom_attribute is the main one I want to finish). I think Java, C# both have that one already
Diego Molina 10:05 PM
Ok, then let’s start with the ones who are around. Only one topic so far: “what is needed for beta 2”
What comes to my head: fixing the leak :slightly_smiling_face:
Simon Stewart 10:05 PM
Crush the leaks. Ensure CDP on Grid to a Docker instance works
Diego Molina 10:06 PM
Regarding the leak, after reading more about the AsyncHttpClient issues and their google group…
10:07
they mention that each AsyncHttpClient instance has its own pool
Diego Molina 10:07 PM
which is why they recommend to have one single instance of it
Puja Jagani
After you pointed out the potential problem area, I attempted to use single instance of the AsyncHttpClient today and still saw the leak :confused: Will try and dig deeper tomorrow. Let me know if you want me to try something in particular.
Diego Molina
One single instance for the whole distributor?
Puja Jagani
One single instance as we had earlier, similar to https://github.com/SeleniumHQ/selenium/blob/selenium-4.0.0-alpha-7/java/client/src/org/openqa/selenium/remote/http/netty/NettyClient.java#L41 java/client/src/org/openqa/selenium/remote/http/netty/NettyClient.java:41 private static final AsyncHttpClient httpClient = https://github.com/SeleniumHQ/selenium|SeleniumHQ/seleniumSeleniumHQ/selenium | Added by GitHub
Puja Jagani
This was just to narrow down the problem area. It was something I was trying to eliminate if creating a new instance is the problem or the way we handle the response (blocking bit you mentioned earlier)
Puja Jagani
Distributor heap with single instance :see_no_evil:
Diego Molina 10:08 PM
additionally you can limit the size of the pool
so I am planning to tweak the client configuration and see if that helps
10:09
sadly, the docs for AsyncHttpClient are inexistent, but it seems like a robust implementation it is used for Gatling
10:09
(a loat test tool)
10:10
load*
David Burns 10:12 PM
@simonstewart what’s left, assuming its everything, to “Ensure CDP on Grid to a Docker instance works”
Simon Stewart 10:12 PM
(In a meeting)
Titus Fortner 10:13 PM
each of the bindings need to be able to implement that part (getting debugger address from caps, etc)
David Burns 10:13 PM
@titusfortner it’s done?
10:14
it gets it from se:options
Titus Fortner 10:14 PM
I don’t think he’s done yet with the first part
he’s changing that
Simon Stewart 10:14 PM
se:cdp now I updated the bindings that use it
David Burns 10:14 PM
@simonstewart touched my code… filthy java person in my python code
Simon Stewart 10:14 PM
The “CDP in Grid” stuff will add se:cdpVersion
Luke Hill 10:14 PM
One of the new things I noticed in ruby (Not sure if it’s relevant across the board). Was the new chrome cdp stuff needs to be able to work in local/remote instances.
Simon Stewart 10:14 PM
“My precious….”
David Burns 10:14 PM
:stuck_out_tongue:
Simon Stewart 10:15 PM
@luke that’s what the se:cdp capability allows
Luke Hill 10:15 PM
One step ahead of me :smile:
Simon Stewart 10:15 PM
The Selenium Server knows how to forward CDP traffic
Titus Fortner 10:15 PM
yeah, Ruby code has never actually allowed users to benefit from browser specific functionality in Remote WebDriver because of subclassing blah blah
Luke Hill 10:15 PM
So check back again in beta2 is the answer basically.
Titus Fortner 10:15 PM
I have a PR to address it
Simon Stewart 10:15 PM
I’m going to make the local drivers also set se:cdp
Titus Fortner 10:16 PM
With that PR, the Ruby CDP code works with server only if it is on localhost, so we’ll also have to update to what Simon has done
Luke Hill 10:16 PM
We “know” what we need to do. Which is half the battle.
Titus Fortner 10:17 PM
With @p0deje been gone for a while and @twalpole being super busy it’s just a matter of bandwidth. :)
well, partly, I only know “ish”
Diego Molina 10:17 PM
it’s the chance for @luke to do some commits :slightly_smiling_face:
Luke Hill 10:18 PM
I can try help where possible. But I’m not quite on their standard.
Titus Fortner 10:18 PM
I’d also like to figure out how to do a different gem publishing for CDP versions
10:19
it’s more important that we be able to update the CDP versions to match the browser versions than Selenium methods to CDP methods, so I’d like to be able to release the artifacts independently, and let users toggle it somehow.
Luke Hill 10:19 PM
By Easter I will hopefully be in somewhere more stable again either renting or buying my first place. So yeh should be able to do more in evenings. This is going to be my fifth property move in just over 2 years
Titus Fortner 10:22 PM
How much work is there still in the leak investigation? (I ask because I literally have no idea what all is involved)
Diego Molina 10:23 PM
Not sure, I’ve invested this week and at least I’ve pinned it down to the Distributor
10:24
It eats memory over time when new tests are executed, and never returns it
I am now checking if the problem is really related to the AsyncHttpClient
10:25
well, more related to the way we use it
David Burns 10:25 PM
@diemol @Puja Jagani knows this is a priority so feel free to rope her in :slightly_smiling_face:
Diego Molina 10:26 PM
they recommend to have a single instance, and in the Distributor we have one instance per registered node, and one instance to do the health checks, and another one that I have not pinned down to see what it is
Simon Stewart 10:30 PM
Because each instance needs its own config
10:31
If we could change config per request, we’d be fine
Diego Molina 10:31 PM
they have a different base url, right?
Simon Stewart 10:31 PM
Right
10:32
And possibly time outs
Anything on the config object
Diego Molina 10:33 PM
I did not see different timeouts, but we will need them when we allow users to configure the timeout in Grid
Puja Jagani
I think the RequestBuilder allows to set timeouts per request.
Diego Molina 10:34 PM
so, hm, interesting… now sure what to do now :slightly_smiling_face:
Simon Stewart 10:35 PM
Once again, I shall mutter about writing our own http client based on netty, starting from the one we have for domain sockets
We’re very happy to announce the release of the first beta of Selenium 4. We’re shipping this for Java, .Net, Python, Ruby, and JavaScript, so if you’re using any of those languages, go and grab it from your package manager of choice!
This has been the culmination of a lot of work by so many people, not only the project TLC, but also of literally hundreds of people: 205 since we released Selenium 3.141.59, at the last count. A big thank you to everybody who’s helped make this possible!
So, what’s changed since Selenium 3? The answer is both “not much” and also “almost everything”.
By “not much”, I mean that if your tests are working with Selenium 3 right now, you should be able to just upgrade your dependency to Selenium 4. You will find that things that were marked “deprecated” are now gone, but the advantage of the long time between the last Selenium 3 release and this is that you’ve had plenty of time to try and find alternatives.
If this doesn’t work, please let us know! We’ve worked hard to ensure compatibility between the releases, but it’s possible we may have missed some things.
One thing you may want to do to get ready for the update (which you can do before updating the dependency itself!) is to update the drivers you need. In particular, please update geckodriver to 0.29.0 or later.
By “almost everything”, I mean that under the covers there have been substantial changes. We’ve rewritten the Selenium server to allow it to work not only in the familiar “standalone” and “hub and node” modes, but also in a new “distributed” mode, which makes it signifcantly easier to deploy to something such as Kubernetes in a way that scales well.
The new server is also wired up with support for OpenTelemetry and exposes a GraphQL endpoint, so that figuring what’s going on in the Grid, and tracking down what’s gone wrong if something happens, is easier than ever.
Not all the changes are server-side. We recently wrote about the new features in Selenium 4 that you can use in your tests, but some of the main highlights are:
We’ll be telling you more about these features in later blog posts, and as we improve our documentation.
If this sounds interesting, please download the beta from your favourite package manager (maven, nuget, npm, pip, or the gem), or directly from the Selenium site.
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on February 11, 2021,5:30 PM CET. (Below times are on CET)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 5:31 PM
Agenda for today:
@simonstewart @barancev @titusfortner @AutomatedTester
feel free to add more topics
intentionally not pinging Jim, Jim is not able to join
@harsha509 @luke and others, feel free to join as well
Simon Stewart 5:34 PM
@titusfortner wants to add “Remove Edge HTML”
Titus Fortner 5:35 PM
maybe a discussion of the general plan for post beta since it looks like the release is imminent?
Diego Molina 5:35 PM
Alright, first thing to mention is… great job everyone dealing with open PRs and open GH issues!
I don’t remember when we had such a “low” number of issues and PRs
but we can keep making that number smaller :slightly_smiling_face:
first topic: Anything new to report from the last PLC/SFC call?
Alexei Barantsev 5:37 PM
I expect the number of bugreports to go up after beta 1 release date
people will download and try the new version
be prepared :slightly_smiling_face:
Titus Fortner 5:38 PM
hopefully. :)
Luke Hill 5:38 PM
ah right. When are these and “should” I be coming to them? Also is there some form of meeting request with link on e.t.c.
I only ask because the cucumber one which I go to i’ve stuck on my calendar so I don’t forget.
Simon Stewart 5:38 PM
@luke there’s a public calendar we share
There’s something every Thursday at 4:30 UK time
Diego Molina 5:39 PM
I believe this is the link to the calendar, Luke https://calendar.google.com/calendar/embed?src=7nmc82h5ok17obircmdu27sghs%40group.calendar.google.com&ctz=Europe%2FBerlin
Simon Stewart 5:39 PM
We announce here 30 minutes before things kick off
Diego Molina 5:39 PM
So, anything from our first topic?
Anything new to report from the last PLC/SFC call?
Luke Hill 5:40 PM
Rightio, is it just typed in here or is there a video call?
Diego Molina 5:40 PM
only typed
Simon Stewart 5:41 PM
Nothing much to report from the PLC/SFC call
Alexei Barantsev 5:41 PM
re: issues and PR, there is a new contributor to the JS part of the project, https://github.com/SeleniumHQ/selenium/pulls/potapovDim I think we should support him as much as possible, he seems to be motivated, I saw he streamed about official selenium JS binding to youtube
Simon Stewart 5:42 PM
We’re waiting for @mmerrell to report back: he was going to reach out to the SFC directly
@barancev +1 for supporting new folks. Anything we can do to help them?
Alexei Barantsev 5:42 PM
the JS part of the crew is traditionally underrepresented… so we should care about JS contributors very much
I’m trying to get into contact with potapovDim to get him more involved
David Burns 5:43 PM
I’ve been trying to make the JS bindings a first class citizen with bazel
I think I have that nearly done
Diego Molina 5:44 PM
ok, the next topic is:
Overall announcements? New people on committees, with the commit bit, etc?
Probably not so much?
Marcus Merrell 5:45 PM
I reached out to SFC about the CoC SOW - Karen responded that she’d look at it “tomorrow” which was last Wednesday. I’ll text her right now to see what she says
David Burns 5:45 PM
cool
our contact for the CoC is still free
Marcus Merrell 5:45 PM
you mean “available”?
David Burns 5:46 PM
No, she has been trying to get back to work but taking it slowly as she is shielding due to covid
Diego Molina 5:47 PM
ok, let’s jump to the main topic then
Pending work that needs to be done for the first Beta?
Simon Stewart 5:47 PM
There’s a few things on my list.
Primarily, the Options classes don’t serialise to a w3c-safe version automatically.
That won’t be hard to fix
David Burns 5:48 PM
My list has Firefox CDP in JS (nearly done)
Simon Stewart 5:48 PM
There’s been a team effort to get the Grid stable. It eats memory, but should work now (@barancev and @diemol can correct me on that)
Diego Molina 5:49 PM
I had these two items on the client side, are the still pending? Make relative locators return elements sorted by proximity Allow locator strategies to be pluggable Enable fallbacks for commands
Alexei Barantsev 5:49 PM
I think that the grid is ready to ship
Jim Evans 5:49 PM
my list is all post-beta1, mostly around refactoring to allow CDP in remote and to enable for firerfox.
Alexei Barantsev 5:49 PM
there is a memory leak, but it’s not critical for the beta
Simon Stewart 5:49 PM
@diemol both of those are done
Titus Fortner 5:50 PM
Firefox CDP shouldn’t need to hold up beta
do we need to fix Options to release beta?
hoping we can release more frequently after we get to beta, just want to know what has to be there for it to be a beta
Diego Molina 5:52 PM
when do we think we can have beta 1 released?
should we set a date for next week?
Titus Fortner 5:52 PM
tonight?
everything is green, so what feature do we need to hold up the release for?
can we do it all in future betas?
Diego Molina 5:53 PM
perhaps the only item is what @simonstewart mentioned?
Simon Stewart 5:53 PM
The Options thing is it, AFAIAC
Titus Fortner 5:54 PM
and we can’t release a beta without it? Is it a user facing change?
Simon Stewart 5:54 PM
It’s suboptimal to not be able to create webdriver instances in java
Titus Fortner 5:54 PM
I completely agree it’s needed
Simon Stewart 5:54 PM
It’s a user-facing change
Titus Fortner 5:54 PM
ok, then :) easy.
David Burns 5:54 PM
I mean… no one uses Java right
Simon Stewart 5:55 PM
Seldom touched.
It’s a niche thing
Jim Evans 5:55 PM
considers changing his name to “no one”
Titus Fortner 5:55 PM
I thought it was an sub-optimized thing that we fix in implementation
but if it changes what a user has to do, then great. Let’s set a date next week? :)
Simon Stewart 5:57 PM
We’ll ship when it’s ready.
But probably next week
Diego Molina 5:58 PM
could we set a tentative date?
So people have it in mind and, if possible, save some time for it
like, we target next Thursday and we touch base on Tuesday to see if we actually can make it, what do you think?
Titus Fortner 6:01 PM
Whatever makes sense to Simon. Ruby stuff should be ready to go on short notice
Simon Stewart 6:03 PM
I’m very time constrained.
But Monday and Tuesday should be selenium days for me
Alexei Barantsev 6:04 PM
let’s ship on Monday then
David Burns 6:04 PM
Python stuff is ready, changelog is already updated
Simon Stewart 6:05 PM
@barancev if everything works on Monday, we ship on Monday
Alexei Barantsev 6:06 PM
yes, if everything works
Titus Fortner 6:06 PM
sounds good to me
excited for it
David Burns 6:06 PM
Let’s not set a date, as much as I want a beta. People will focus on it too much
Diego Molina 6:06 PM
sounds good, my intention was just to drive this conversation :slightly_smiling_face:
Titus Fortner 6:08 PM
Are we ready to talk about removing EdgeHTML? :)
Diego Molina 6:08 PM
got for it
Titus Fortner 6:09 PM
who wants to keep it in Selenium4?
No one? Ok, let’s remove it.
:)
Simon Stewart 6:09 PM
I’m going to let @jimevans make the call
Titus Fortner 6:10 PM
seriously, though, it’ll be less confusing for calling “edge” methods in Se4 to represent the latest instead of having to require people to specify “edge_chrome” and “edge_html”, etc
Simon Stewart 6:10 PM
I’m fine with edge and edgehtml
Titus Fortner 6:10 PM
well “edge” used to be edgehtml
Simon Stewart 6:10 PM
Everyone who’s lazy will get the right thing by accident
Titus Fortner 6:10 PM
so it’s going to be a change either way
but I’m fine with whatever @jimevans decides on it
Jim Evans 6:11 PM
let me make the call regarding EdgeHTML?
Simon Stewart 6:11 PM
Yeah
Titus Fortner 6:12 PM
should we all ditch explicit support for it in Se 4 since MS is forcing people off of it… :)
Alexei Barantsev 6:12 PM
@titusfortner we provide support for IE :slightly_smiling_face:
Titus Fortner 6:13 PM
IE is and will remain special
Diego Molina 6:13 PM
this is about EdgeHTML, not IE, right?
David Burns 6:13 PM
Looks like bwalderman submitted a patch for python to remove it a while back
Titus Fortner 6:13 PM
I think MS can force upgrading from EdgeHTML to Edgium more easily than forcing people to upgrade IE
David Burns 6:13 PM
bwalderman of John Jansen’s team
Alexei Barantsev 6:13 PM
@diemol yes, EdgeHTML, not IE
Jim Evans 6:13 PM
given that they’re doing forced-upgrades of people on EdgeHTML, i’m inclined to remove support for it. sure as we do, you know people will still be like “how do i test against edgehtml, since i don’t give any reflection on what my users are actually using and don’t want to have to think critically.”
is quite cynical today.
David Burns 6:14 PM
so… that was my question really…
Simon Stewart 6:14 PM
I’m down with removing it from the java tree, then
David Burns 6:14 PM
is Sauce dropping support for it?
or magic “here is an old selenium to support it” type code
Titus Fortner 6:15 PM
if the decision were up to me, yes, but it isn’t, so ¯_(ツ)_/¯
Diego Molina 6:15 PM
to be honest, I don’t know how we are doing it
David Burns 6:16 PM
we could ask your product team especially since they are starting their day or … drop it with a big YOLO
Diego Molina 6:16 PM
but if it is browser that won’t be supported by MS starting on March(?), we will eventually drop it
Titus Fortner 6:16 PM
I can see valid use cases for IE, I don’t see valid use cases for old Edge, and yeah, it’s all complicated since things have changed since 3.141.59
Diego Molina 6:16 PM
goes and asks the team in charge
Titus Fortner 6:17 PM
Dude, we still support running Firefox 4 on Vista
David Burns 6:18 PM
screenshots this for that team if they come moaning…
Titus Fortner 6:18 PM
So, you can test EdgeHTML with MutableCapabilities if you need to
David Burns 6:19 PM
the python code treats them the same, just creates a different service
Titus Fortner 6:21 PM
Titus: supports Jim: inclined to support
anyone else with opinions on keeping it?
it’s really the force upgrades that is pushing me to be more drastic in the recommendation, plus the potential confusion over the method
David Burns 6:22 PM
I’m happy to drop
Diego Molina 6:22 PM
+1 to that
Titus Fortner 6:22 PM
@barancev?
Oh, missed Simon saying he’s good with it
whew, ok, I’ll stop banging on about it :)
thanks
Diego Molina 6:25 PM @titusfortner, maybe you can create a GitHub issue and add labels for each language binding? Then we can track it
Titus Fortner 6:25 PM
Another ask…
Can we create a list of the new features that the bindings need to implement so that we can make sure all the languages are supporting the same things?
Some of the stuff being done in Java I’m not sure if it is grid related or bindings related.
I know Ruby is missing a few things, and I’m not even sure I know which all of them are.
Diego Molina 6:28 PM
I think we would need to go through the changelogs and build that list
David Burns 6:30 PM
@titusfortner thanks for offering to make sure the docs are up to date
Titus Fortner 6:30 PM
Can we make a grid in an issue, or do we need to track it elsewhere
I legit tried to help with the docs, but Go kicked my butt and I threw in the towel
I’m sticking with Jekyll where the OO makes sense :)
Diego Molina 6:31 PM
an issue would be nice
David Burns 6:31 PM
What…
@titusfortner you should watch my twitch… the docs are easy
Diego Molina 6:32 PM
Can we make a grid in an issue, or do we need to track it elsewhere
I am replying to this
lol
David Burns 6:32 PM
The what was for Titus
Diego Molina 6:32 PM
ok, so the meeting time is up, thank you everyone!
In the fourth and final post in his series, Simon Stewart continues talking about what’s coming in Selenium 4 and reviews what’s new in the Selenium Grid.
We’ve covered a lot of ground in the past few blog posts, including how to contribute to the project, and some details of what you can expect as a Selenium user. But there’s more to Selenium than just the APIs you use to write your tests, and one of the big features we’ve not covered yet is the refreshed Selenium Grid: a mechanism that allows you to distribute your tests across a fleet of machines.
Before going further, it’s always nice to acknowledge where we’ve come from, not only because it’s interesting, but also because it helps explain the “why” of the refreshed design.
Way back in the mists of time (2008), Jennifer Bevin and Jason Huggins worked on a system called the Selenium Farm at Google. This was a fleet of machines sitting in a cupboard somewhere that allowed you to run the original Selenium protocol. This was, of course, at Google scale, so there was more than one cupboard :)
This allowed people at Google to distribute their tests and scale out beyond their individual machines. This was such a great idea that when Jennifer talked about the Farm at a Selenium meetup, Philippe Haringou (then at ThoughtWorks) decided to write an Open Source implementation of the same thing, which he called “Selenium Grid”.
Selenium Grid was a lovely piece of technology, but it had one drawback: it only spoke the original Selenium RC protocol. That was fine, but WebDriver spoke a different wire protocol, which was called the JSON Wire Protocol, and folks wanted to be able to use both Selenium RC and WebDriver at the same time.
This is where Francois Reynaud enters the picture. He was working at eBay, reporting to Michael Palotas, and he had written something like the original Selenium Grid, but which also worked with the JSON Wire Protocol. They very kindly contributed that work to the Selenium project, and it formed the basis of the Selenium Grid 2. We decided at the time that the Selenium standalone server would effectively be a “grid of one”: it would have everything you needed in it to set up a Selenium Grid, as well as to work as a single standalone server. Merging the code and getting it stable took a while, but thanks to the efforts of Francois, Kristian Rosenvold, and many others, we merged Grid 2 into the main Selenium project and shipped Selenium 2 in 2011.
Even if 2011 doesn’t feel that long ago, the modern world has changed quite significantly. In 2011, we didn’t have Docker. We didn’t have Kubernetes, we didn’t really have AWS. So, the Selenium Grid didn’t know that those things were coming in, and wasn’t written to take advantage of them. Fortunately, we did have virtual machines back then, and the Grid 2 had been designed to be able to support them.
This was the hook that an excellent project called Zalenium. Developed by Diego Molina, Zalenium added a really nice UI and support for Docker and Kubernetes—all built on top of the Grid 2. This has allowed the Selenium Grid to continue to be relevant and useful to this day, which is an amazing achievement.
But, like I said, it took us time to stabilise Grid 2: about six months of hard work, largely led by Kristian. That’s because while Grid 2 was sophisticated, the code was hard to read and hard to maintain—and very few people could do that. Worse, the merging of the Grid 2 and the original Selenium server was pretty crude; effectively there were two separate servers shipped in the same binary. This led to problems occurring in the Grid but not when run in standalone mode, and vice versa.
With Selenium 4 we’ve decided to bite the bullet and address these three concerns. Firstly, we want something that was easier to work on and maintain. Secondly, we want to merge the servers into a single unit. Thirdly, we want something that will take advantage of the world of modern infrastructure we have available to us now, not just in the form of Docker and Kubernetes, but also to be able to use emerging technologies such as distributed tracing.
To do this, we looked at the functionality the Grid provided, and to model each piece as a component that we can either run “in memory” (allowing us to have a single standalone server), or in a more distributed way, allowing the “hub and node” architecture that we’re familiar with from the original Selenium Grid, to a fully distributed design.
The first component is the “router”. It serves as the entry point to the Grid. You can expose it to the internet and it directs requests to the Grid. It’s designed to be stateless, and so you can add more to Grid as you find you need to.
When the router sees a new session request, it places it on a “session queue.” The session queue is read by a component called the “distributor,” which maintains a model of all the places in the Grid where a session could be run: we call them “slots”. The slots are hosted by components called “nodes,” and each node can have one or more slots. When the distributor pulls a new session request from the queue, it identifies the most appropriate slot to use, and forwards the request to the node which owns the slot. Once the node has started the session, the distributor puts the session ID and the URL of the Node that is running the test into the “session map”—you can think of the session map as being a simple map of a session ID to URL—and the new session response is sent back to the waiting test.
Requests for running sessions (that is, for most webdriver calls!) are handled slightly differently. The router will use the session map to look up which node to forward the request to, avoiding the need to involve the distributor entirely. This means that you can just keep adding nodes to the Grid, and there are fewer bottlenecks in the architecture to slow your requests down.
Conceptually, there are these five moving pieces within the Grid. But there’s actually a sixth one, which is a message bus. The five Grid components communicate internally through the message bus, but the actual components that you need to think about when you’re thinking about the Grid are the Router, Session Queue, Distributor, and Nodes.
When you run Selenium Grid 4 in “standalone” mode, you actually get a “grid of one”. We wire up all these components in a single process, but they’re all still there.
You can also run it in the traditional Hub and Node approach that you’ve seen with Selenium Grid 2, where you fire up a Hub and a Node and it registers. If you’ve used Selenium Grid recently, that’s probably the architecture that you’re familiar with. In this case, most of the components (the router, session queue, and distributor) are running in the Hub, and the Nodes run the sessions themselves.
What’s new with Grid 4 is that you can go into a fully distributed mode if you want to. Typically, you would want to use something like Kubernetes for this, and some of the key components are designed to store data using a database or Redis for better reliability and scalability.
Something to note is that when running a distributed Grid, it becomes really difficult to figure out what is happening, particularly when something goes wrong. To alleviate that problem, we have adopted Open Telemetry to bring observability into the Grid. What do we mean by observability? It simply means that we want to be able to see everything that happens.
Finally, we’d like to expose information about the running Grid in meaningful and useful ways. The original Grid supported both JMX (a Java management API) and an HTML-based console. While nice, this didn’t make it easy to query specific areas of the Grid that you might be interested in that weren’t surfaced by the UI (for example, how many slots are available, or to find out which node a particular session is running on) To provide more flexibility, we’ve chosen to provide a GraphQL endpoint for the Grid. To ensure that GraphQL endpoint is sufficiently flexible, we’re building the new Grid console using it. That should allow you to also extract useful metrics and information from the Grid for your monitoring needs.
Those are some highlights of the new Selenium Grid. What are you the most excited about?
This was originally posted at https://saucelabs.com/blog/whats-coming-in-selenium-4-the-new-selenium-grid
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on January 28, 2021,5:30 PM CET.(Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 9:17 PM
Yes, here is the short agenda:
Alexei Barantsev 9:44 PM
can the Bot drop the meeting link to the chat, please, I always forget where to get it…
Diego Molina 9:53 PM
this is the written one
Alexei Barantsev 9:58 PM
awesome! I’m in yet I have nothing to add to the agenda
Diego Molina 10:01 PM
sounds good I’ll ping people around and we can wait a couple of minutes, Simon said he was going to be slightly late
10:02 PM
@titusfortner @jimevans @mmerrell @manoj9788 @AutomatedTester @harsha509 @luke
Jim Evans 10:03 PM
i’m not going to be able to make the video chat, but i can contribute here if people have questions. the only thing missing from .NET for beta1 is making CDP work via remote, which i don’t think needs to be in beta1 for .NET.
Diego Molina 10:06 PM
this is just the written one, the video chat is just to hangout, that one is next week
Marcus Merrell 10:06 PM
no status chance on the Chicago conference at this point - still looking at COVID numbers to determine whether or not it’s going to be feasible
David Burns 10:07 PM
here! sorry
Diego Molina 10:07 PM
Marcus are we still looking into an online event, Marcus?
Marcus Merrell 10:07 PM
we can look into that haven’t been to this point
Diego Molina 10:08 PM
I only ask because (I think) it was mentioned last time ok, perhaps we can start, the first topic is: Overall announcements? New people on committees, with the commit bit, etc?
10:10 PM
Aside from @luke joining recently, there are no more things to announce, right?
Sri Harsha 10:10 PM
I think luke joined recently!
Simon Stewart 10:10 PM
Nothing that I can think off
Alexei Barantsev 10:12 PM
I support @diemol’s appeal to focus attention to the issue tracker. let’s try to clean it up in view of the forthcoming v.4 release
10:13
close all outdated issues and PRs, apply everything that worth applying
Diego Molina 10:13 PM
the work done during the recent week on the issue tracker has been great, hopefully we keep that going
10:14 PM
we could jump into the next topic perhaps… Pending work that needs to be done for the first Beta? here is the list I have from the last meeting
10:15 PM
Simon Stewart 10:15 PM
Relative locators now sort by proximity I think the Java Module stuff is working I’m working on fallbacks for locators
Alexei Barantsev 10:15 PM
I can confirm that java 9 modules are usable now
Simon Stewart 10:16 PM
Locator strategies are pluggable on the server side Once I get the locator strategies falling back on the local end, I’m fine with shipping the beta
Diego Molina 10:17 PM
we had some issue reports related to the Grid, in most of the cases it is a matter of showing the correct information on the UI and I am working on that
Simon Stewart 10:18 PM
Also there’s a nasty issue with starting a large number of sessions concurrently
Diego Molina 10:18 PM
yeah, I was going to point that one out, https://github.com/SeleniumHQ/selenium/issues/9112 I have not had time to research enough, but most of the results when googling point to: either we are creating too many Netty clients or something is wrong with the way the client is created
David Burns 10:20 PM
Feel free to pull in @Puja Jagani on the sessions one, I know she was looking at one about starting up a grid and things not working
10:20 PM
(can’t remember the issue #)
Diego Molina 10:20 PM
that’d be great, I can sync with @Puja Jagani later what do you all estimate for a beta release? 3-4 weeks?
Simon Stewart 10:21 PM
Maybe less
Diego Molina 10:23 PM
ok, I think we do not have more things pending for beta 1? the only topic left is the CoC New
Titus Fortner 10:24 PM
Is this a good time/forum to ask about wiki/docs?
Diego Molina 10:24 PM
always
Titus Fortner 10:25 PM
Diego pointed me at a couple issues @AutomatedTester created for docs & wiki cleanup things did we have an idea for what we want in the language specific wiki page vs in the docs; and user vs developer focused? The Ruby wiki stuff is way out of date, not even just Selenium 4 things :) just want to know where we should be cleaning it up to
Diego Molina 10:28 PM
are those two different things? language specific things and dev docs? (people who want to contribute to Selenium, what technical steps to follow?)
David Burns 10:28 PM
CoC is still waiting on SFC. New
Titus Fortner 10:29 PM
What we did with Watir was to make the wiki about things devs need to know about the project building/deploying, etc and everything user related went into the documentation oh, heh, looks like we ended up deleting the wiki and sending everything to the website
Diego Molina 10:32 PM
Why do we need a language bindings specific things on the user docs? Do they differ too much on how they work?
Titus Fortner 10:33 PM
So our current documentation has tabs to show the examples in each of the languages the wiki is currently just a big page of examples for using Ruby Selenium (https://github.com/SeleniumHQ/selenium/wiki/Ruby-Bindings)
10:37
I guess I haven’t spent much time with the docs anyway, so maybe I should play around and see what makes sense. Didn’t know if anyone else had opinions on any of it. :) Guess not
Diego Molina 10:38 PM
ah ok, that Wiki seems to be duplicating the user docs but some parts of the Wiki could evolve to be part of the user docs
Titus Fortner 10:39 PM
yeah, it’s 2 approaches to organization as well; here’s everything in ruby, vs here’s everything, click the tab for each to see the ruby.
Diego Molina 10:39 PM
I think the 2nd could work well someone needs to take the time and take the contents of that Wiki and put them in the docs
Titus Fortner 10:39 PM
I’ll take a look at what might make sense since now that I no longer have any looming work pressing things for the first time in forever
Diego Molina 10:40 PM
cool thank you
I think that was it for today, right?
Thank you everyone!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on January 14, 2021,5:30 PM CET.(Below times are on IST)
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 10:02 PM
Alright, :wave: everyone, let me share the agenda
10:02 PM
10:04 PM
pinging @titusfortner, @AutomatedTester, @mmerrell, @barancev
who else?
Simon Stewart 10:04 PM
@jimevans @p0deje @harsha509
Jim Evans 10:05 PM
i’m already in another meeting at the moment.
Sri Harsha 10:05 PM
m available
Diego Molina 10:05 PM
ok, let’s bring the first topic: Overall announcements? New people on committees, with the commit bit, etc?
David Burns 10:05 PM
here
Diego Molina 10:06 PM
So, I asked both to the TLC members about adding @luke as a committer, and I also reached out to Luke, both sides are happy with it.
David Burns 10:06 PM
cool!
Diego Molina 10:07 PM
Then, I will add Luke during the next couple of days and follow the steps we have in the Governance model
Simon Stewart 10:08 PM
Congratulations, @luke! :tada:
Diego Molina 10:09 PM
great! So, I think we have nothing else to add to this point?
Marcus Merrell 10:09 PM
I’ve got approval emails out to SFC to get the new contractor on the Code of Conduct. It’s time to poke again. We’ve tentatively selected dates for a Chicago SeConf (sometime in September, I believe). We’re still hopeful that with the vaccine, this will be possible. we’ll look to make a final decision, based on numbers, in ~April :parrot:
10:11 PM
We need to consider whether or not to run a virtual conference in the case that it doesn’t work out to have an irl conference
Simon Stewart 10:11 PM
Can that decision also be delayed until April?
Marcus Merrell 10:11 PM
I’m a little uncomfortable waiting that long–not for the hotel and the risk of losing the deposit $$, but because of marketing/CFP stuff let’s say “early April”
Diego Molina 10:12 PM
Great news about the CoC! ok, seems we covered also the “Anything new to report from the last PLC/SFC call?” topic as well, right?
Simon Stewart 10:14 PM
I think so
Diego Molina 10:15 PM
ok, so let’s jump to “Pending work that needs to be done for the first Beta?”
Simon Stewart 10:15 PM
There’s a few things
10:16 PM
I’ve a PR out for the new RemoteWebDriverBuilder, which is one piece. The other big bit for me is the pluggable locators, tying up the local and remote ends bits we already have. That’ll be easier with the RemoteWebDriverBuilder in place.
10:17 PM
(As it’s essentially creating new decorators of the CommandExecutor) I’d also like to ensure that things like the relative locators and script pinning work as advertised, but that’s a relatively slim tranche of work My next hacking days are Monday and Tuesday next week
Diego Molina 10:18 PM
here is a list from the previous status meeting: Client facing changes:
10:19 PM
I think this is (partly?) done “Allow locator strategies to be pluggable” and I remember @simonstewart did this “Make relative locators return elements sorted by proximity”
Simon Stewart 10:19 PM
I did The Java Module System thing is a good point, but not a huge amount of work
10:20 PM
Though it’s a little fiddly
Titus Fortner 10:20 PM
is the “pluggable” part a Java specific thing, or something new that the server is going to support that opens up new opportunities for dynamic languages?
David Burns 10:20 PM
@Puja Jagani could probably look at the Java Module work
Puja Jagani
Sure! I can take that up
Simon Stewart 10:20 PM
I can discuss the changes with her
10:21 PM
@titusfortner the remote end bits of the pluggable locators allow us to avoid sending large payloads across the wire for (eg) finding by react But it requires the local end to know in advance that it can use that mechanism Tying the pieces together with a fallback allows the local end to try the efficient way first and then fallback to the inefficient way
10:22 PM
It shouldn’t be a particularly challenging thing to do once the pieces are all nicely lined up, but getting the pieces lined up has taken time :slightly_smiling_face:
Diego Molina 10:24 PM
I am slowly getting more time to work on some open issues and getting some items from that list on the server done, like using failsafe for retries
Puja Jagani
I created a PR to get started on that front for transient errors, please have a look when time permits. I think that might serve as the starting point.
Diego Molina
perfect, will do
Simon Stewart 10:24 PM
I think the BrowserStack folks (particularly @rajendra?) are hacking on the Grid UI and can give an update on that I’m happy to punt the failsafe stuff for the beta, but it really should be in place for the 4.0 release
Diego Molina 10:24 PM
I saw one or two GH issues related to that, if I am faster than @rajendra I can tackle it and get familiar with the UI I would leave this one out as well Pipe VNC connectors through the websocket plumbing for live video
10:25 PM for beta 1 hopefully it could be there for the 4.0 release
Simon Stewart 10:25 PM
I think that’s just a case of adding the video URL to the se:options in the server Should be in the same place as we add the bit for cdp
David Burns 10:26 PM
I had a quick look at the grid-ui in a stream… my CSS sucksbut happy to pair up and fix
Diego Molina 10:26 PM
ah, so the scope is way smaller than what I was thinking
Simon Stewart 10:26 PM
The WebSocket forwarding either works or it doesn’t. If it doesn’t, CDP over the Grid is broken And I already got the CDP over Grid working :slightly_smiling_face:
David Burns 10:26 PM
@Puja Jagani is looking at adding a few more issues with graphql that we can surface
Diego Molina 10:27 PM
so we offer the WebSocket endpoint and the user can use it to stream
Simon Stewart 10:27 PM
Can we “drain” using GraphQL yet?
David Burns
I dont think so
David Burns
we can get the grid ui to call a normal url
Simon Stewart
The idea would be to use GraphQL for the entire UI….
David Burns
We can add it “soon” but since it works we don’t need to block a beta on it. Let’s have a stretch for it
Simon Stewart
But it doesn’t work if you have a distributed grid
Simon Stewart
It’s one of the “tracer bullets” of the graphql stuff, and really does need to be in
Simon Stewart
I want the beta as much as anyone, but there are some corners we should avoid cutting
Simon Stewart 10:27 PM
@diemol it’s a tiny bit more than that, but, yeah
Diego Molina 10:27 PM
I thought we wanted to put that in the Grid UI
Simon Stewart 10:27 PM
We do before 4.0
Diego Molina 10:27 PM
we would need to embed a VNC client in the UI for that
Simon Stewart 10:27 PM
But for the alpha, I’m happy with the endpoint being exposed and being able to wire up a vnc viewer locally that goes through the grid @diemol what did zalenium use?
Diego Molina 10:28 PM
noVNC, but that was something that you need to install on the host, IIRC
10:29 PM
ah, I think it also has a JS library, it “should” work there is also an alternative called “Guacamole”
Simon Stewart 10:29 PM
http://guacamole.apache.org might be useful Ha!
Diego Molina 10:30 PM
right, so I can look at that at some point
Simon Stewart 10:30 PM
Awesome. Thank you
Diego Molina 10:30 PM
coming back to pluggable locators, it is working in Java but we would need the other bindings to implement it, right?
Simon Stewart 10:31 PM
When it’s working in Java, yes :slightly_smiling_face: But I think it’s enough to get them in one binding for the beta, and the others can follow
Diego Molina 10:31 PM
Also, the reworked logic for relative locators has been implemented only in Java?
Simon Stewart 10:32 PM
The reworked logic was in the atom. Everyone has it Yay for the atoms!
10:32
:slightly_smiling_face:
Diego Molina 10:32 PM
That’s great! Do we have anything else? I will (for sure) this time create GitHub issues for the different items
Simon Stewart 10:34 PM
And add them to the project plan, please!
Diego Molina 10:34 PM
absolutely
Simon Stewart 10:35 PM
Thank you
Diego Molina 10:36 PM
Well, I think we do not have other topics, should we cut it short? New
Simon Stewart 10:38 PM
I’m down with that. Thanking for running this! Unless @jimevans has something to add? I see he’s typing
Jim Evans 10:38 PM
re pluggable locators: that’s just having findElement(s) call down the wire using the end point without validating the using and value params, yeah?
Simon Stewart 10:39 PM
That’s what the java code does at the moment
Jim Evans 10:39 PM
cool. .NET can do that too right now, i think (will have to confirm)
Simon Stewart 10:39 PM
I want to land a few more smarts
David Burns 10:39 PM
I expect the python and ruby code can do it to since monkey patching is easy and then add smarts too improve docs ftw
Diego Molina 10:43 PM
ok, seems we are done with the status meeting, thank you everyone!
Jim Evans 10:45 PM
re beta readiness: i have a refactor to .NET i want to do to make CDP via RemoteWebDriver easier/more correct, but it can wait until post-beta1
10:45
otherwise, i think .NET is ready for beta.
Below is a summary of the Selenium survey that was collected.
Unsurprisingly, people find having to manage browsers a task they wish they didn’t have to do and wish that Selenium did this. 59.5% of respondents want Selenium to manage the browsers for them. This, though the question didn’t ask this, is to include the browser drivers.
The results show an interesting view into framework usage. 61% of users use a framework. When we look closer at some of the responses there could be a little language bias in there. Some responses in the “both” category are “depends on the language” or “depends on the project”. Frameworks, from a couple responses seem to be around JavaScript mostly.
One of the questions that was the most surprising was that people dislike running their tests in headless. 57% of people don’t want headless. This is surprising since puppeteer and playwright are up and coming tools that default to headless.
People tend to favour evergreen, or the latest version from auto updating browsers, with over 55% of people wanting that. When we look at the data closer then people tend to do evergreen and then a specific version for IE.
People are also, overwhelmingly I should add, wanting to test on multiple browsers. 78% of people test with multiple browsers. This goes against the Chrome only support that we see on social media. The most used browsers for testing are (Percentage of respondents testing with browser):
Google Chrome (98%)
Firefox (67%)
Microsoft Edge (33%)
Safari (29%)
IE (13.5%)
One thing that is clear is that Testing against multiple browsers is hard. 51.6% say it’s hard and a further 27.3% being 3 out of 5. This is likely where some frameworks are becoming popular as it removes some of the need to understand the asynchronicity of browsers. This still has its problems in puppeteer and playwright as they add similar wait libraries to what Selenium has.
One of the most surprising things to have come out of survey was the want to use mobile browsers more.
Of the 410 respondents 367 want to test on mobile. Interestingly, this goes well past just Chrome for Android and Safari for iOS.
Below is a list of browsers and percentage of users wanting to use it. Questions were designed for Android unless it said iOS. See note at the end of the section.
Firefox for Android: 38%
Chrome: 91%*
Microsoft Edge: 14%
Samsung Internet: 16.6%
Safari on iOS: 69%
*Note that the questionaire only mentioned Chrome so it could be a conflation between platforms here. 1 Person used the other field to add Chrome for iOS.
Language support is what one would suspect with most users using Java or python.
java: 67%
python: 31%
ruby: 6.1%
.NET: 17.6%
JavaScript: 21.4%
PHP: 1.5%
After reviewing the “What one thing would you improve about Selenium I was able to narrow most of the responses down to similar types.
Below is a breakdown of the issues that people would like to see improved.
Of the 410 respondents, 219 had something nice to say about Selenium and were thankful for the product being around.
Some of the main reasons are simplicity of APIs, good backwards compatibility, and it being open source
In the third post in his series, Simon Stewart continues talking about what’s coming in Selenium 4 and reviews some of the tricks in the new release.
In my last posts, we talked about how to contribute to Selenium, and why we’re bumping the version number to 4. That’s enough preamble! Today, we’ll cover some details about the new tricks and capabilities that Selenium 4 offers.
You know, finding elements on a page can be really difficult. I’ve seen loads of people using very complicated XPATH expressions, and trying to figure out complex CSS selectors and things like that. There have been whole talks about the subject at SeleniumConf. Surely there must be a better way to do this?
Think about how we describe where an element is on the page. Think about how you’d do this over the phone. You’d never talk about the raw DOM, “Ah, find the fifth DIV element nested inside the SPAN with an ‘id’ of ‘foo’”. You’d just never say that! Instead, you’d say something like, “just find that thing above that image, and to the right of that link,” when talking about where things are located on the page.
A long time ago, a project called Sahi started to locate elements like this. Sahi had Relation APIs, which are a lovely way of finding elements, and it was very, very fluent and pleasant to use. When I was starting WebDriver years ago, I was talking with Narayan (creator of Sahi) and I promised him that I was going to hold off implementing this flagship feature of Sahi. It was something that was lovely, but it was also something Sahi was rightly proud of. However, there are now other tools, such as Tyco, that are implementing this style of API, so it seems like the time is right to do the same in Selenium. In Selenium 4 we call them “relative locators.” You may sometimes see us refer to them as “friendly locators,” since the initial implementation called them that, but “relative” better describes how they work. We have a handful of them: near, above, below, left of, right of. They allow you to talk in human language about where an element is on a page.
Looking at the future, we are also planning to enable users to add new types of locators, not only on the, on the client side, but also to the Selenium Server. For example, although JS UI frameworks come and go (anyone else remember using jquery?), it’d be nice to be able to add a custom locator for the current tools people like, such as React.
One feature that people have been asking for since we started the project has been the ability to authenticate to a web site. Previously, you could do this by crafting the URL the browser went to properly, but this leaks credentials to any man-in-the-middle and leaves them in server logs, so browsers have slowly removed this piece of functionality. That’s unfortunate, since it’s something that we know people frequently need to do in their tests. In Selenium 4, we now offer a mechanism to register a username and password that can be used to authenticate against these sites.
A common complaint of Selenium tests is that they’re slow and flaky. While the bindings to the browser are excellent, and fully described by the W3C WebDriver spec, it is true that any end-to-end test is likely to suffer more flakiness than a simple unit test—there are just more moving parts, and more possibilities for things to go wrong.
One way to resolve this issue is to stub out the backend of the application, intercepting network traffic in the test and returning pre-canned responses. Tools such as mountebank make this easy for API testing. Wouldn’t it be nice if there was a similar tool for Selenium?
With Selenium 4, we now provide a mechanism to do this, using the NetworkInterceptor (well, that’s what we call it in the Java bindings). Pass it your WebDriver instance, and it’ll be called every time the browser is about to make an HTTP request, allowing you to return almost anything you want
As I mentioned previously, one of the nice things about Selenium 4 is our work to ensure a stable and modern user-facing API. What does this mean? To start, we need to acknowledge that after a long time there’s now competition back in the browser automation space. Notably in the form of Puppeteer and Cypress, and taking a step back, what do they offer? They build upon the Chrome DevTools Protocol (CDP)>, which is a protocol developed to enable a debugger inside Chromium-based browsers.
Because of what it was designed to do, it is a chatty protocol, and not a user-facing API that allows you to introspect into the browser. Worse, introduce a network hop between the test and the browser, this chattiness leads to slower tests as the network latency increases. That is why tools such as Puppeteer want you to run on the local machine. That’s great for the speed of an individual test, but makes parallelisation harder, as you can’t use services such as Sauce Labs easily.
To complicate matters, because the CDP is designed as a debugging protocol, it can change with no notice between versions. That’s why Puppeteer and Cypress are tied to specific versions of browsers, and that causes a dilemma for you as a test author: how do you test on multiple versions of a browser? Updating the test API to get a different browser can lead to you no longer making valid API calls. Not doing so ties you to a potentially outdated version of a browser.
Despite this, using the CDP opens up a host of possibilities, and that’s why we’ve added support for it in Selenium 4. In fact, some of our new features are built on top of it (though we hide the details!)
But we’ve also gone further that just adding basic support. Selenium 4 can support multiple versions of the CDP at the same time, meaning you can test with both the current and beta versions of Chromium-based browsers without needing to rewrite tests. We do this by providing an “idealised CDP”, which is stable and covers the features we feel tests need. If that idealised view of the world isn’t enough for you, we also expose the raw CDP APIs too, giving you flexibility to choose what’s best for your tests.
We’re feeding this experience into the new W3C WebDriver Bidi specification, which is helping make that a better fit for testers.
I am leaving out of this post all the details related to another important trick in Selenium 4, the new Selenium Grid, which I will cover in the next post. Stay tuned!
This was originally posted at https://saucelabs.com/blog/new-tricks-in-selenium-4
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on December 03, 2020,5:30 PM CET.
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
Diego Molina 5:32 PM
So, things from the previous meeting
General project statistics
Diego Molina 5:35 PM
here are the topics that we initially cover today:
Overall announcements? New people on committees, with the commit bit, etc?
Anything new to report from the last PLC/SFC call?
Pending work that needs to be done for the first Beta?
are we all around to start?
Simon Stewart 5:38 PM
@titusfortner @jimevans @p0deje @barancev @AutomatedTester @harsha509
David Burns 5:39 PM
I’m here
Diego Molina 5:41 PM
The first topic is: Overall announcements? New people on committees, with the commit bit, etc? I believe there is not much about this, right?
Simon Stewart 5:41 PM
Nothing from me
David Burns 5:42 PM
nope
Diego Molina 5:43 PM
Maybe, just for awareness of the meeting minutes, for the ones who read them we are doing a survey that will help with the future of Selenium https://twitter.com/SeleniumHQ/status/1333830343368077319
David Burns 5:44 PM
We’ve had nearly 400 respondents
Diego Molina 5:44 PM
and Boni García replied to it with https://www.mdpi.com/2079-9292/9/7/1067 I have not read it yet
David Burns 5:44 PM
if you haven’t retweeted the survey, could you do that please?
Simon Stewart 5:44 PM
I hadn’t seen the reply
Diego Molina 5:46 PM
Boni is the creator of WebDriverManager and a JUnit 5 extension for Selenium I think he is a professor at a university in Madrid
Simon Stewart 5:47 PM
I’m glad WebDriverManager exists
Diego Molina 5:47 PM
Alright, maybe we should have a read at that document and report our findings :slightly_smiling_face:
So, probably we can move to the next topic: Anything new to report from the last PLC/SFC call?
I think there was one call a couple of days ago
David Burns 5:50 PM
Main question: did someone follow up on my CoC request?
I did email again
and mentioned it to @mmerrell
Simon Stewart 5:51 PM
Monday is my next Selenium day. If no-one has responded by then, I’ll chase
Diego Molina 5:52 PM
ok, probably we can move to the next topic and circle back to this one if someone has more information
Pending work that needs to be done for the first Beta?
This is what we wrote/discussed in the previous meeting:
Client facing changes:
Server changes:
I have on me the task to map this list into GitHub issues in case they do not exist (I have not done it yet)
Simon Stewart 5:54 PM
I’ve made relative locators return elements sorted by proximity
Diego Molina 5:54 PM
is there something else to add? do we have an status update on any item?
Simon Stewart 5:55 PM
My plan on Monday is to look at pluggable locator strategies
Which will require fallbacks for commands
David Burns 5:55 PM
I’ve been working with the Mozilla folk to add bidi support for Firefox, there are bugs on their side that they are working on
Marcus Merrell 5:55 PM
I’m sorry, @AutomatedTester , I never received an email about it. I don’t know if there’s a list I’m not on, or if my address is wrong, or if it went to spam, but I don’t have it
I’ll be glad to follow up if I can get the info
David Burns 5:56 PM
@mmerrell I emailed selenium@sfc
Marcus Merrell 5:56 PM
Right… guess I need to verify that I’m on that
Simon Stewart 5:58 PM
You should be.
Diego Molina 5:59 PM
Which will require fallbacks for commands I am sorry I never found the time to check your branch and work on it
Marcus Merrell 5:59 PM
I haven’t seen any of the sponsor emails either… starting to think there’s a problem
Diego Molina 6:02 PM
ok, so I believe we don’t have any more comments for this?
Simon Stewart 6:02 PM
Not from me
(Looks like a short meeting today, he says. Jinxing it)
Alexei Barantsev 6:04 PM
as for the beta1, I’m going to add commands getAriaRole and getAccessibilityName and I call java api complete
Diego Molina 6:05 PM
perhaps the last thing to mention is that I have pending to fill out the table about who has access to the distribution engines (npmi, sonartype, etc…) so the idea is that I will make sure we all have access to all of them
Simon Stewart 6:05 PM
Speaking of which, we really do need to push a JS release
Anyone want to volunteer for that?
David Burns 6:05 PM
If it’s not done this evening I will do it
about to take youngest to ballet so will be out for a few hours
Alexei Barantsev 6:06 PM
I’ve enabled GitHub integration in sonarcube, so it should sync org members and provide access
Simon Stewart 6:07 PM
That’s nice
Thank you
Diego Molina 6:09 PM
well, so I think that’s it for this meeting, right?
Simon Stewart 6:10 PM
I think so
Diego Molina 6:11 PM
ok, then, thank you all!
Titus Fortner 6:49 PM
Sorry to miss; I was giving training. Also, I miss getting to travel for these; Zoom is just not the same…
Titus Fortner 7:02 PM
I haven’t looked, has the print pdf endpoint been added to all the bindings? I haven’t looked in past 2 weeks, but Ruby & .NET needs to implement FF Full Page screenshot, Java (.NET?) need to be able to tell Firefox to take a full Page Screenshot when using RemoteWebDriver Java & Ruby need to re-fix the STP browser name
Ruby stuff was on my to-do list, until my paid work job gave me a daunting task with a short timeline
Jim Evans 7:04 PM
.NET hasn’t added print-to-pdf yet.
nor full-page screenshot.
Titus Fortner 7:06 PM
on that note @barancev I couldn’t duplicate the Ruby Remote Firefox bug on Mac, and VirtualBox appears to be a disaster running on Mac because I can’t even get it to play nicely with a Linux install to test it there. NET read timeout is often a random network problem, but it looks like we’ve been seeing the error consistently, so I’m concerned about it being a real problem. @p0deje do you have a linux machine available to see if we can replicate locally?
Alex Rodionov 9:35 PM
@titusfortner Not really and frankly I don’t have spare time to set it up to investigate
Speaking of which, I’ll be leaving for a 1 month road trip next week and I won’t be able to do any Selenium work during that time. Likely till early February in fact. If there is anything I can do before that, please let me know.
Titus Fortner 9:39 PM
@p0deje when do you leave?
Alex Rodionov 9:40 PM
Next Wednesday
Titus Fortner 9:45 PM
oof, well I’ve been assigned to create and give 20+ hours of classroom training on Selenium for a client between now and EOY, and I have maybe half of that right now :) I should be more available in January to help, but I’ve spent more time with the Selenium java code than Ruby code recently, so I’m not sure how we have the DevTools stuff implemented. @twalpole what’s your availability this month? :-D
David Burns 9:49 PM do we have people to do releases for ruby with @p0deje away?
Alex Rodionov 9:50 PM
According to https://github.com/SeleniumHQ/selenium/issues/8168, a currently missing CDP stuff in Ruby is: Intercept network requests allowing to mock backend requests Bootstrap script Record traffic The first two I believe are implemented in Java so it should not be hard to redo it in Ruby. I might give it a shot this weekend. The latter I think is missing in all bindings. @titusfortner we can hop on pairing session and I’ll guide you through the code. Otherwise, it all lives in devtools directory
@AutomatedTester Yes, Titus can do releases
David Burns 9:52 PM
don’t forget that @rajendra can help, BS is a ruby shop so we can help
he’s been looking through the code for the devtools stuff and is working the print stuff
Titus Fortner 10:02 PM
I’ll have bandwidth to do a release, but not to dig through the implementations until January :)
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on November 19, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on December 03, 2020,5:30 PM CET.
Simon Stewart 9:53 PM
@diemol are you running today’s status update?
Diego Molina 9:55 PM
I can do that I always forget because the event has no notifications
let me look for the agenda Some numbers before starting: Previous meeting: 281 open issues, 61 open PRs Current: 280, 62 PRs
Simon Stewart 9:58 PM
I’ve added a 30 minute reminder to the meeting in Google Calendar
Diego Molina 10:00 PM
From previous agendas, I believe these could be the topics:
10:00
Feel free to add topics
10:01
Should we start? pinging @AutomatedTester @titusfortner @harsha509 @jimevans @manoj9788 @mmerrell @barancev @p0deje
Sri Harsha 10:04 PM
m in
Simon Stewart 10:04 PM
Here!
Diego Molina 10:05 PM
First topic: Overall announcements? New people on committees, with the commit bit, etc?
David Burns 10:05 PM
here
Simon Stewart 10:06 PM
We really need to agree an emoji for “I’ve nothing to say”
:shushing_face: maybe?
David Burns 10:06 PM :speak_no_evil:
Diego Molina 10:06 PM
:speak_no_evil:
Simon Stewart 10:06 PM
I like that We shipped 4a7 Nice work, everyone
Diego Molina 10:08 PM
ok, let’s move to the next topic :slightly_smiling_face:
2nd topic: Anything new to report from the last PLC/SFC call?
Simon Stewart 10:09 PM
I missed it
David Burns 10:10 PM
There were notes from @jimevans re: a meeting at the end of October, was that the last SFC?
https://seleniumhq.slack.com/archives/C013TSZD4P5/p1604415853013000
Diego Molina 10:12 PM
right, I remember that, probably that covers the topic then, next one :slightly_smiling_face: 3rd topic: Pending work that needs to be done for the first Beta?
Simon Stewart 10:13 PM
There’s a lot. Mostly in Java I think we should all get together at some point and figure out how closely our CDP-based functionality aligns I think it’s pretty close, but I know that there are few things that @jimevans did that I’d like “take inspiration” from
David Burns 10:14 PM
Can we get things documented since you can be a bottle neck due to life. How can we, being my team, help here?
Simon Stewart 10:14 PM
10:16
Server changes:
@AutomatedTester ^^ I documented them :stuck_out_tongue: CDP for Firefox would be handy too
David Burns 10:17 PM I am going to start CDP for Firefox tomorrow
Simon Stewart 10:17 PM
Are there docs on how to find the ws address to use?
David Burns 10:17 PM
No… I will document it
Diego Molina 10:17 PM
we really need some sort of docs to have a decent feature parity across bindings
Titus Fortner 10:17 PM
does all the CDP stuff work for Edge as well right now? I haven’t tried anything but Chrome so far
David Burns 10:18 PM
I have a “try” build of geckodriver with it that I need to play with
Simon Stewart 10:18 PM
The Java stuff works for edge too
Titus Fortner 10:18 PM
I was doing a brief analysis of some things for a talk I was giving, and we implemented features in Selenium 3 at very different versions between the bindings. Kind of surprised me :)
Simon Stewart 10:18 PM
Heh. Jari was fast :slightly_smiling_face:
David Burns 10:19 PM
misses Jari
Diego Molina 10:20 PM
do we have GitHub issues for the items missing for beta?
Jim Evans 10:20 PM
those notes were from the 3 november call, which was the last PLC call (they only happen monthly)
Simon Stewart 10:20 PM
Most of those things are in the project plan, @diemol
Jim Evans 10:21 PM
so there’s a bug in .NET alpha7 that prevents the bindings from working with grid 4. (it’s fixed now)
Titus Fortner 10:21 PM
I mentioned recently that Java & Ruby don’t have the right STP name still in 4 alpha and .NET & Ruby both need to add support for full page screenshots in Firefox. Not sure what list that needs to get added to? (I’ll try to get to the Ruby stuff this weekend)
Jim Evans 10:22 PM
print-to-pdf end point?
Simon Stewart 10:22 PM
@jimevans I think the check in the java bindings may be a little too extreme, so we may need to loosen things there too @titusfortner good point. The STP thing is irksome. I need to dig into it
Jim Evans 10:23 PM
sorry i’m late to the party, btw. was spending a few minutes with P this morning before her first client.
Titus Fortner 10:23 PM
I tried to fix it in Java, but I was missing pieces. Someone who knows what they are doing, should be easy
Simon Stewart 10:23 PM
It’s not easy If it was, I’d have fixed it already :slightly_smiling_face: Or @barancev would have
Titus Fortner 10:23 PM
STP went from “Safari” to “Safari Technology Preview” back to “Safari” I changed Ruby to the longer version when I thought I was using the latest STP (I was not)
Simon Stewart 10:24 PM
I think I need to tease apart the two versions of the browser more
Titus Fortner 10:24 PM
I think we just need to support the latest version
Simon Stewart 10:24 PM
I’ll have a chat with folks here to figure out the Right Thing to do
Jim Evans 10:24 PM
i want .NET to undergo a radical refactor in its class structure before 4.0 releases. now that we have a web standard, the current class hierarchy is wrong.
Simon Stewart 10:24 PM
Yeah, just the latest version
Jim Evans 10:24 PM
well, not really “radical,” but definitely a change
Simon Stewart 10:25 PM
@jimevans we really need to find a way to get someone helping you with the .net stuff
Jim Evans 10:25 PM
nothing breaking, API-wise. with .NET 5 being out, it should be a fair sight easier.
Diego Molina 10:27 PM
We can spread the word about the help we need in the different bindings, either for refactoring or reaching feature parity if we have those changes described somewhere, ideally a GitHub issue. Then we could tweet or something, saying we need help with this issue.
David Burns 10:28 PM
Well… I have an idea I would like to share towards this but I can do that at another time unless now is a good time
Simon Stewart 10:28 PM
The Java module stuff is obvious if you use java modules
Jim Evans 10:28 PM
so, right now, the .NET class hierarchy is RemoteWebDriver (implements IWebDriver et al) -> all browser-specific drivers. what it should be is abstract class WebDriver (implements IWebDriver) -> RemoteWebDriver, and also abstract WebDriver -> browser specific drivers. if i’m clever about it, this will not be a breaking API change, because IWebDriver is still A Thing™.
Simon Stewart 10:28 PM
Just like the java 8 issue was
Diego Molina 10:29 PM
Please share, @AutomatedTester
Jim Evans 10:30 PM
my ${paidWork} project is approaching a bit of stability, so i should be able to devote some time between now and the end of the year, hopefully.
Jim Evans 10:30 PM
my ${paidWork} project is approaching a bit of stability, so i should be able to devote some time between now and the end of the year, hopefully.
David Burns 10:31 PM I would like to, with support of this group, see about creating a Yak Day. The idea is, and it requires a bit of upfront work, to get issues in place for this and then see if we can get contributors
Jim Evans 10:31 PM
the idea in Selenium 5 is to start phasing out the use of IWebDriver in favor of using the abstract base class.
David Burns 10:32 PM
it would also require that I, or others, do a “How to contribute” video to share before hand
Jim Evans 10:32 PM
(sorry for the parallel idea-spewing into the channel, but i’ve been thinking about this, and not really talked about it to anyone outside the multiple voices in my own head.)
David Burns 10:32 PM
and if we split it accordingly to language bindings and services we can see if we can try build out a bit more support for each langauge and may get us more contributors.
Simon Stewart 10:33 PM
There’ll be hoops I need to jump through, but I can jump through them to make that happen
David Burns 10:33 PM
I appreciate it can flood us with junk and we would need to work out to how to prevent that
Simon Stewart 10:33 PM
I’ve got some half-written docs for building with bazel for selenium.dev too
David Burns 10:33 PM
but the general gist is create tiny bits of work to build up contributors
Titus Fortner 10:34 PM
So, I don’t know what everything that is on the lists mentioned above entails, but I do want to put in a generic plug that we make sure things absolutely need to be in 4.0. If we can release something “good enough” to iterate on through 4.x releases, it’s going to be *much better than a super polished codebase that isn’t released for another 6 months.
Diego Molina 10:34 PM
that would be really great
David Burns 10:35 PM
I agree @titusfortner, while we are in alpha we have a limited usage group but we have finite resources so its a fine line to tread
Titus Fortner 10:36 PM
nope, totally understand; we’re all volunteers and such. just requesting we keep in mind that perfect is the enemy of releasing something that makes current users lives better
Simon Stewart 10:36 PM
After 4.0 ships, I’m going to be stepping away I’ll probably stay involved with WebDriver Bidi, but I won’t be cutting code
Diego Molina 10:37 PM
no no, you cannot leave us alone with bazel :smile:
Titus Fortner 10:37 PM
Yeah, I get that this is a factor for sure :)
David Burns 10:37 PM
Bazel isn’t that scary
Titus Fortner 10:38 PM
isn’t the point of bazel that we shouldn’t have much issue with it once everything transitions? :-D
Simon Stewart 10:38 PM
I’ll still be hacking on bazel
David Burns 10:38 PM
I’ve been contributing to that community recently… going to overtake @simonstewart knowledge soon :smile:
Simon Stewart 10:38 PM
One can only hope
Jim Evans 10:39 PM
bazel is fine… as long as your language and toolset’s opinions don’t conflict with bazel’s
David Burns 10:39 PM
@jimevans I’m finding that works with all languages… but that’s an aside
Simon Stewart 10:39 PM
@jimevans I want to see better .net support in bazel What I need is a) time, b) a Windows machine
Jim Evans 10:40 PM
well some languages’ tooling are more opinionated than others. (see: MSFT is all in on MSBuild, and any other build tool will always, always, always be a second-class citizen.)
Diego Molina 10:40 PM
Can the project buy you one?
Jim Evans 10:41 PM
@simonstewart i’ve had remarkably good luck using VMs and VMWare Fusion.
Simon Stewart 10:41 PM
My hard drive is currently stuffed with multiple versions of macOS.
Jim Evans 10:41 PM
like, that’s been my exclusive .NET dev environment for going on 8 years now.
Simon Stewart 10:42 PM
Once I get more storage, I can try a VM again
Diego Molina 10:42 PM
but ok, to the topic, which was Pending work that needs to be done for the first Beta? I believe we have commented the most of it
10:43
I will go through the meeting minutes and then create GitHub issues if I don’t find any for the items mentioned
Simon Stewart 10:43 PM
For me, “beta 1” means “this is what you’ll get in 4.0, but there are known issues”
Jim Evans 10:43 PM
.NET needs to add the “make CDP user scenarios easy” methods to be added.
Diego Molina 10:43 PM
and I will ping you to add details about it
Jim Evans 10:44 PM
yikes that’s atrocious grammar. but you get my meaning.
Diego Molina 10:44 PM
should we move to the last two topics? we have 16 minutes left
David Burns 10:44 PM
go for it :slightly_smiling_face:
Diego Molina 10:44 PM
4th topic: Users/passwords, access keys, etc… to distribution and release repositories. So, recently @AutomatedTester & me got access to the project to release Java, but in general, if we ever need to do a release and the key folks are missing we do not have access to this information
Jim Evans 10:45 PM anyone who wants access to the nuget repo, create a nuget.org account (requires a “microsoft account”), and let me know. i’ll add you to the organization for selenium.
Titus Fortner 10:46 PM
who owns email access to selenium.dev? I think we should get a project email/password for these things instead of each using our own?
Sri Harsha 10:46 PM
i got access to npm selenium-webdriver package
Diego Molina 10:46 PM
for example, we were able to get access to the npm org recently, so @harsha509 could do a JS release
David Burns 10:46 PM
and we got access for NPM :wink:
Diego Molina 10:46 PM
I thought we could be more proactive in this and not wait until we need the person to share the access.
Titus Fortner 10:47 PM
I mean, if people sign up for rubygems and send me their email, I can add them to the list of authorized users; but might scale better if there were a lastpass/onepass/whateverpass that stores universal credentials…
David Burns 10:47 PM
The only place I can think of is nuget python has a few people but we can add more. The other place is Google Storage, do we have enough people with access there?
Simon Stewart 10:49 PM
I’ve got Google Storage. @jimevans does too. I think Luke may still have the keys.
Diego Molina 10:51 PM
I believe it is a matter of someone doing the work and going one by one to give access to the TLC to all what we need. I can find some time to do that
10:52
ok, then the last topic 10:52 CoC, next steps?
David Burns 10:53 PM
CoC is waiting on SFC/PLC to reply to my message I should follow up I have found a contractor, ex-head of D&I from Mozilla, to help do the work
lukeis:indeed: 10:55 PM
yeah, i still have the google storage keys… tucked away in an archive i put in my personal google drive :grimacing:
Simon Stewart 10:55 PM
I’ve put together a quick Google Doc for folks to add their names to for access to release pathways.
David Burns 10:56 PM
thanks @simonstewart!
lukeis:indeed: 10:57 PM
we got rid of the google app-engine driving seleniumhq.org right?
Simon Stewart 10:58 PM
I can’t remember where we deploy selenium.dev to It may still be app engine
David Burns 10:58 PM
selenium.dev is on github pages
Diego Molina 10:58 PM
We use GitHub Pages
David Burns 10:58 PM
via Hugo
Simon Stewart 10:59 PM
https://github.com/SeleniumHQ/seleniumhq.github.io/blob/dev/.github/workflows/deploy.yml#L26 .github/workflows/deploy.yml:26 uses: peaceiris/actions-gh-pages@v3 https://github.com/SeleniumHQ/seleniumhq.github.io|SeleniumHQ/seleniumhq.github.ioSeleniumHQ/seleniumhq.github.io | Added by GitHub
lukeis:indeed: 11:00 PM
yeah, the sehq app engine still exists… and the dashboard seems like it’s still getting some kind of requests (very few) wonder if it’s still handling some redirects
Diego Molina 11:02 PM
it should be mostly redirects I need to leave, but thank you all for joining!
Titus Fortner 11:02 PM
Thanks @diemol!
In the second post in this series, Simon Stewart continues talking about what’s coming in Selenium 4 and why this release has a major version bump.
In my last post, I shared a bit about how the Selenium project works overall. Now, let’s start talking about Selenium 4 and what’s coming. One thing I think I should clear up is “why the major version number bump?”
Sometimes I joke that the major reason for the version number bump is that while the digits of Pi are infinite, when we went from 3.14 to 3.141, people got a little bit upset. Moving to 3.141.5 and then 3.141.59 was as far as we wanted to push that particular idea :)
More seriously, the first reason is that we have a revised Selenium IDE. Years ago, this used to be Firefox only because it used the XPI extension mechanism (which was specific to Firefox). It’s now a web component, and you can download it for Chrome, Firefox, and anything else that supports Web Components. There is currently work to rewrite it as an Electron app, which will allow us to make better use of the native OS the IDE is running on. That work was largely pushed forward by developers working at Applitools. They started from a base of the original Selenium IDE that had been migrated to use Web Components by a company called SideX. It’s been a fantastic example of the community working together well.
Secondly, we have fully adopted the W3C WebDriver protocol, and have dropped support for the original home-grown wire protocol. The way that Selenium communicates with a web browser is via a wire protocol that’s effectively just JSON over HTTP. Originally this grew organically as we figured things out, and we tried to make browsers do what we needed them to. That original protocol is known as the JSON wire protocol because it spoke JSON over the wire (and we’re not great at coming up with very original names).
That original protocol was the base for the W3C WebDriver protocol, which smoothed some of the rough edges, and brought some much needed consistency to the protocol. The two major areas the standardised protocol improved on included session creation, where we removed considerable ambiguity, and by providing a far richer API for specifying user actions.
So what does this adoption of the W3C protocol mean for you? I’ll be honest: it probably doesn’t mean much to you at all. If you’re using a modern browser (released over the past couple of years), you will find that actually you already speak the W3C protocol with Selenium 3.
So who does care about the protocol dialects? When we talk about companies like Sauce Labs who provide Selenium as a service—they care about it. The ecosystem is ready for this next step, because the technical folks at these companies have ensured that they understand and comply with the W3C protocol, and folks from the Selenium project have been there offering help and advice as needed.
One of the other nice things about Selenium 4 is that we’ve done our best to ensure a stable user-facing API. That means when you upgrade your project from Selenium 3 to Selenium 4, it should be a drop-in upgrade. You just change the version number, recompile and you should be done.
There are a few caveats that you should be aware of, however! The major one is that if in the last version of Selenium 3 a method was deprecated, it’s now probably gone. We’ve taken the opportunity of a major version bump to delete them and clean up the behind-the-scenes internals people don’t normally get to see. If you’re a software developer, you may recognise this as us paying off some of our technical debt :)
Stay tuned for the next post, where I’ll go over some new tricks in Selenium 4.
This was originally posted at https://saucelabs.com/blog/whats-coming-in-selenium-4-why-the-major-version-bump
In this new blog series all about the upcoming release of Selenium 4, Simon Stewart will cover how the Selenium project works, who is involved, how you can get involved, and a sneak peek at what’s new in Selenium 4.
As the lead of the Selenium project, I wanted to kick off a new blog series leading up to the release of Selenium 4. During this series, I’ll talk all about how the Selenium project works, who is involved, how you—yes, you!—can get involved, and we’ll get a sneak peek at what’s new in Selenium 4. I’ve been speaking about this off and on for a while, but now the 4.0 release is looming I wanted to start sharing in more depth.
In this first post, we’ll start off with a brief discussion about how the Selenium project itself runs and who does what, because that’s a really helpful piece to understand how and why things happen the way they do on the project. In future posts, we’ll look at the new IDE, and then we’ll talk about Selenium 4 in more depth, including the fact that it should be a drop-in replacement for you. I’ll also review some new features that we’ve added to Selenium 4, and talk a bit about the modernized Selenium Grid. So let’s get started!
Selenium is an Open Source project. It’s run under the aegis of the Software Freedom Conservancy (SFC). The SFC is a group dedicated to pushing forward Free and Open Source software. Besides Selenium, they have a handful of projects you may have heard of, including Samba, Mercurial and Git. The SFC allows us to focus on writing code and fixing bugs by handling all the legal and financial stuff we’re not good at. They’re the ones that help us negotiate contracts for when we want to run SeleniumConf, for example.
Acting as a bridge between the project and the SFC is the Project Leadership Committee
(PLC). Currently, it’s made up of Jim Evans, Alexei Barantsev, Marcus Merrell, Manoj Kumar,
and myself. What do we do? Effectively, the PLC is about providing a smaller group of people
for the SFC to talk to when decisions need to be made about funding a conference, or how
best to respond to sponsorship agreements. Because we like to do as much work in the open
as possible, you can find us on the #selenium-plc
Slack channel, and almost every
conversation and topic is discussed here.
One of the key qualifications for being on the PLC is a demonstrated commitment to helping the Selenium project improve and succeed, and we recognise that the project is more than just “code.” It’s a community, and the make up of the PLC reflects that.
The Technical Leadership Committee (TLC) includes the people who set the technical direction
for the project. If you come over to the Selenium Slack, you can find the #selenium-tlc
channel,
which is where a lot of the technical conversations happen for the project. The TLC includes Jim
Evans, Alexei Barantsev, David Burns, Diego Molina, Titus Fortner, and me.
How do you get on the TLC? Although the project governance document goes into more detail, it can be summed up as simply as someone who’s demonstrated technical leadership on the project, over an extended period of time. Just as with the PLC, being on the TLC doesn’t give someone more authority, but they’re the ones who can merge PRs, and who can (if need be) commit directly to the tree.
Again, the TLC tries to do as much work as possible in the open. If you’re ever interested in watching
the design discussions, or asking why a bit of the Selenium code base is structured the way it is, then
come and join us in the #selenium-tlc
Slack channel. There’s normally someone from the project there
who’ll be able to answer your questions!
I wanted to share how the project works for one simple reason: to highlight one of the really important things with Open Source, which is that anyone can contribute! You don’t need to be throwing code around in order to be contributing, and you don’t need to be special in order to contribute your time and effort.
So obviously there’s the people running the projects and writing code, but we couldn’t do that all on our own. Every release includes contributions from a variety of people, not just the core development team. Also, we’re always happy to accept patches. If you’re not quite sure where to start, I recommend you head to our GitHub page and take a look at the project tab. That’s where you can see the things that need to be done and what we’re working on.
The other way to get involved is the way that everyone used to get involved with Open Source, which is by what’s known as “scratching your own itch”. It’s if there’s something about the project, something about the product you think could be a little bit better, download the source, edit it, and then send us a PR.
We encourage you to get involved and contribute! On the Selenium website, there is a
page that outlines in detail the steps to join the Selenium team.
Join the Selenium Slack channel to interact with us and ask questions. If you want to discuss something,
or if you don’t understand why the code is written the way it is, feel free to come on to that Slack channel
and talk to us. Also, if you’d like to see how the decision making is made, then please do feel free to come
on to the #selenium-tlc
or the #selenium-plc
channels to see those groups. Because we’re Open Source, we
try and do everything in the open.
If you’d like to put faces to people’s Slack or IRC handles, then please note that there’s a regular team meeting every other Thursday on Google Meet at 4:30pm (UK time!) We tend to just chat and discuss everything from the project to the weather, but that’s a great way to get to know people a little better! :)
Finally, if you’re having trouble getting to grips with the Selenium code base, then please do come and ask us for help. We’ve done our best to make the on-ramp as easy to take as possible, but the project can seem complicated and daunting when you’re getting started. We’re here to help!
I hope you enjoyed this intro to the Selenium project. Next week, we’ll talk about why the major version bump to Selenium 4. Stay tuned!
This was originally posted at https://saucelabs.com/blog/whats-coming-in-selenium-4-how-can-i-contribute
It’s that time of the year where working groups from the W3C meet up to discuss the various standards that are being worked on.
Within the Browser Testing and Tools Working Group, there are 2 different standards.
We have:
The first is what is commonly supported by the Selenium Project and has support from Apple, Mozilla, Microsoft, and Google in their browsers. It is also supported by various Selenium in the cloud providers like Sauce Labs and BrowserStack.
As the world has moved on we have felt the need to add new APIs and move Selenium to be more event-driven. This is where we are learning, and collaborating, with projects like Puppeteer to make sure that we can improve the Browser Automation space. This is where the WebDriver-Bidi Specification comes in. It has broad support from the browser vendors so you can use official browsers and not be limited by the JavaScript sandbox. Some of the newer frameworks can’t guarantee that.
If you’re curious about we discussed this week, feel free to read it up on the W3 Wiki.
This post was originally shared on David Burns’ Blog
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on October 08, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on October 22, 2020,5:30 PM CET.
Diego Molina 9:03 PM
Perhaps the main topics to discuss are these ones: Anything new to report from the last PLC/SFC call? Pending work that needs to be done for Alpha 7?
9:03
anything else that we need to talk about?
Simon Stewart 9:04 PM
Also paging @mmerrell and @manoj9788
9:05
Not much to share from the PLC call this week
9:05
Tentative thoughts about where we might be able to host SeConf next year, and puzzling out whether we can meet in person
Marcus Merrell 9:05 PM
here now
Simon Stewart 9:06 PM
@mmerrell can give more of an update
Marcus Merrell 9:06 PM
if I understand it correctly, we have ~$40,000 tied up with the Chicago venue, and it would be the path of least resistance to hold it there
9:08
we’ll start meeting around the first of November to start planning something there… I’d much rather hold it in the EU, but with the loss of White October, we’d need to a) find an organizing entity, and b) be prepared to pay ~double what we paid WOE, and only have a conference of half the size (i.e. we’d likely lose $$). We’ll need to decide whether or not it’d be worth it
Diego Molina 9:12 PM
if we plan ahead of time, and things are ok in terms of covid, it can happen in the EU, we have contacts here. We could ask orgs that have conferences like Agile Testing Days to give us a hand. Just throwing ideas here.
9:13
Or the folks at MoT
9:13
Next topic?
Simon Stewart 9:14 PM
Sure
9:14 Alpha 7 talk?
Diego Molina 9:14 PM
Yes
Simon Stewart 9:15 PM
@jimevans is working on the CDP stuff for .Net
9:15
I’m busy implementing some of the nice features we’ve wanted for a while (including things like script pinning)
9:15
I know that @AutomatedTester has mostly wrangled Python into shape with the CDP stuff
Diego Molina 9:15 PM
We have the PRs for the queue, which I reviewed but it’d be nice if you have a look again, Simon
9:16
(grid)
Simon Stewart 9:16 PM
But I don’t know if it supports multiple versions
9:16
I can have a look at them tomorrow
Diego Molina 9:16 PM
Specially 8754, not sure about using two concurrent arrays there
9:17
Aside from what you mentioned, and the PRs for the queue, I think we are good for Alpha 7
Simon Stewart 9:18 PM
Aye
Diego Molina 9:19 PM
sooo, I think we are done with the meeting?
Simon Stewart 9:27 PM
I think so
9:27
Unless there’s anything else people want to talk about ?
Diego Molina 9:36 PM
Doesn’t seem like that Thank you everyone!
This year the Selenium Conference was held virtually, and despite that, the conference was again that exciting place where the Selenium community meets every year to share and learn about the most popular browser automation tool in the world. The conference offered talks about improved testing practices, new tools to simplify the setup of automated tests, the future of Selenium, and lots of learnings from speakers who shared their use cases and practical advice for how they use Selenium at work.
Here are some takeaways and interesting talks from this year’s conference:
A peek at the upcoming Selenium 4 release was possible thanks to the demo Simon Stewart gave during this traditional talk that happens in every Selenium conference. Selenium 4 is shaping up nicely and will leave the Alpha state soon. We are all looking forward to the betas, and a candidate release shortly after that. The talk also invited other members of the Selenium team to share the organizational work they have been doing in the project, including diversity, governance and welcoming contributors.
Varuna Srivastava gave a talk together with Wim Selles that showed how to build a robust and scalable framework for UI testing, based on WebdriverIO. It showed concepts that are important when getting started with JavaScript, NodeJS, and the NPM ecosystem. Furthermore, there was a broad overview of WebdriverIO and its shiny features, as well as a demo on how to use TypeScript for testing. This is a recommended talk for anyone who wants to get started on testing with JavaScript.
This was an interesting talk from Jesus Sanchez, where in order to avoid having the QA department as a bottleneck for the growing team of developers, they took the approach of building tools and resources for developers and enabling them to write tests for their over 40 websites. It is an interesting take on how the QA role becomes a facilitator and an enabler for the rest of the organization, while coaching everyone on how to write automated tests and the value of testing the right thing.
Smita Mishra gave a captivating talk where she invited all testers to think what alternative paths could be present in their careers, given that some organizations value testing more than others. Smita showed that if you understand what you enjoy the most, and find a way to combine that with your current and future skills, it could show you how to grow your career by finding and following a path of the least resistance.
JUnit 5 is the new iteration of this popular testing framework, and it implements a new programming and extension model named Jupiter. Boni García presents in this talk a JUnit 5 extension called Selenium-Jupiter, the demos showed illustrate how useful this extension is because it simplifies the test configuration and reduces the boilerplate code that needs to be written in order to have a test running. Have a look at it because it is well maintained and documented, and it will help you by reducing the time needed to set up your tests.
One of the keynotes in the conference was done by Jim Evans, where he relates a personal journey through his career and how clearly “not special” he considers himself. One of the key takeaways is the fact that you become a major contributor and you do not need to be special to do that. No review will make enough justice to highlight how heartwarming and encouraging this talk was, it is a must watch for anyone who wants to become a contributor.
The final session of the conference was the keynote where the project committers do an open Q&A with the community. Different opinions were shared around the question of the challenges the Selenium project sees by the growing number of browser automation tools. In addition, all project contributors made an open invitation to the community to get involved in the project, if you are interested in that, please check the project’s governance document. This is another recommended session to watch, lots of insights about how the project and its individuals work that will help the community understand the project better.
This was originally posted at https://opensource.saucelabs.com/blog/selenium_conf_2020_recap/
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on September 24, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on October 09, 2020, 4:30 PM CET.
Diego Molina 9:00 PM
So this is the proposed agenda, and @AutomatedTester has some more topics: General project statistics
David Burns 9:00 PM
I dont have more topic, I want to discuss some of those topics
Diego Molina 9:01 PM
I need to improve reading skill :slightly_smiling_face:
9:01 PM
OK, let’s start
Simon Stewart 9:01 PM
settles in
Diego Molina 9:02 PM
General project statistics Previous meeting: 334 open issues, 63 open PRs Current: 281, 61 PRs We are slowly cleaning the list of issues, more cleaning to come :slightly_smiling_face:
Simon Stewart 9:02 PM
Another 32 weeks, and we’ll be done (Well, PRs)
David Burns 9:03 PM
I think we should pat ourselves on the back. In February we had over 600 issues
Diego Molina 9:03 PM
Absolutely
9:04
Ok, next topic Overall announcements? New people on committees, with the commit bit, etc? I am not aware of any announcements…
Simon Stewart 9:04 PM
Not that I’m aware of
Diego Molina 9:04 PM
Ok, so probably the next topic won’t have any updates either Anything new to report from the last PLC/SFC call?
Simon Stewart 9:05 PM
Not from me
Diego Molina 9:06 PM
Perfect, so let’s jump to the next one Pending work that needs to be done for Alpha 7?
Jim Evans:black_medium_square: 9:06 PM .NET needs a fair bit of refactor for CDP i’m planning on taking all day tomorrow to look at that.
David Burns 9:07 PM
Oh that’s awesome
Simon Stewart 9:07 PM
The java code is in a releasable state, I think Though I broke a test in the distributor, so I may want to fix that before landing
Rajendra Kadam 9:07 PM
I am working on js cdp stuff
David Burns 9:07 PM
The python code for here is just me putting in the work to make the API not suck
Jim Evans:black_medium_square: 9:07 PM
once i get CDP generation redone for C#, i’ll be pretty happy with the state of the .NET code base.
Simon Stewart 9:07 PM
There’s the session queue PR that it’d be nice to land, but I don’t think it’s essential
David Burns 9:07 PM
@p0deje has the Ruby stuff done
Diego Molina 9:07 PM
I am reviewing @Puja Jagani’s PR about the session queue, it’d be nice to have it for the alpha
Simon Stewart 9:07 PM
@jimevans this is good news :slightly_smiling_face:
Jim Evans:black_medium_square: 9:08 PM
i do need to think about a “version independent API for CDP” for .NET
Titus Fortner 9:08 PM
Do we need cdp for alpha 7? There are a number of bug fixes from 6 to get out there
Simon Stewart 9:08 PM
I’d like us to have a fairly unified approach between (at least) java and .net for the unified CDP. Happy to make changes to the java tree to make that happen
David Burns 9:08 PM
The queueing stuff I think needs to be in the alpha so we can get it to nightly users
and then improve in the betas
Jim Evans:black_medium_square: 9:09 PM
@titusfortner i at least need to get that version-independent api done before alpha7. .NET skipped alpha6 altogether, because i suck.
Simon Stewart 9:09 PM
@titusfortner in the java tree, the new CDP stuff has allowed us to hook in a bunch of APIs. It’d be nice if those were in other languages too
David Burns 9:10 PM
but… feature wise after that we’re done right? I’m itching to get us out of alpha we’re not getting enough usage
Simon Stewart 9:10 PM
I think we’re basically there once it’s done How’s the UI looking?
Diego Molina 9:11 PM
Sounds like it, for Alpha 7, to summarise: CDP working across bindings Session queue in Grid
David Burns 9:11 PM
the UI is there, I think. We’ve fixed the main UI issues
Jim Evans:black_medium_square: 9:11 PM
i agree with that assessment. once CDP work for .NET is done, i’m considering it feature-complete for 4.x.
David Burns 9:11 PM
and that’s all in trunk
Diego Molina 9:13 PM
Great, I am not sure if there is anything else to add to the topic
Simon Stewart 9:13 PM
Other than a proposed date to release a7?
David Burns 9:13 PM
next week (no pressure everyone)
Jim Evans:black_medium_square: 9:14 PM
wednesday or after of next week. i’m sure i’m not going to get it all done in one day.
David Burns 9:14 PM
Thursday and Fridays are our normal release dates so that sounds good
Simon Stewart 9:14 PM
I’m going to make a decision to gate the release on @jimevans saying that .Net is ready to roll
Jim Evans:black_medium_square: 9:14 PM
to quote @AutomatedTester “no pressure” :slightly_smiling_face: we’re putting a stake in the ground saying a7 is our last alpha?
Simon Stewart 9:15 PM
With a hard stop-date of 2020-10-07 For java, yes And I think we have the most moving parts
Jim Evans:black_medium_square: 9:15 PM
(agreed as a7 being last alpha for .NET too)
Diego Molina 9:17 PM
Any comments from other bindings? @AutomatedTester @titusfortner @rajendra @harsha509?
David Burns 9:17 PM
I want us out of alpha so…
Simon Stewart 9:17 PM
@AutomatedTester we all want to be out of alpha
Rajendra Kadam 9:17 PM
working out for js, some tests issues, trying to fix those
Simon Stewart 9:17 PM
But we also don’t want to move “just because”
Sri Harsha 9:18 PM
JS is already in alpha 7, can we release JS npm with like alpha7-patch1 with CDP ?
Simon Stewart 9:18 PM
Bump JS to alpha8 Keep it simple :slightly_smiling_face:
Sri Harsha 9:19 PM
ok, Thank you @simonstewart
Diego Molina 9:21 PM
Does it make sense to discuss the next topic? “Betas”
Simon Stewart 9:22 PM
We can move on from “alphas” :slightly_smiling_face:
Diego Molina 9:22 PM
Like, having a timeline or something like that for Betas?
David Burns 9:22 PM
There are a number of issues that are “assigned” in the “in Progress” part of https://github.com/SeleniumHQ/selenium/projects/2 I think understanding which of those features are needed for use to move through the betas is important
Simon Stewart 9:23 PM
I have a pile of branches locally with changes If it’s in the 4.0 roadmap, that kind of suggests it’s needed before release If it’s not in the roadmap, we don’t need to worry about it (For the release itself) (We do need to worry about it)
David Burns 9:24 PM
so… I guess my request is, if you’re doing it, what can we do to get it sorted (like hand off to someone else) or if you’ve not started can you unassign yourself I think it would be good to get a clearer picture of where people can help
Simon Stewart 9:25 PM
I’m not actually assigned to that much
David Burns 9:25 PM
this is a comment to all of us really
Simon Stewart 9:25 PM
One code review, one “add support for retries to handlers” I’ve a local change that has the skeleton of retries written, as well as fallback URLs for commands
Diego Molina 9:27 PM
I’ve seen that one and wanted to check, but time hasn’t been on my side lately
Simon Stewart 9:27 PM
Join the club :slightly_smiling_face:
David Burns 9:28 PM
so part of my request really is knowing where I can help without having to badger you all I being me and my team
Simon Stewart 9:29 PM
Getting Grid rock solid would be really helpful I suspect we’re not really using ZMQ properly And if that falls over, we’re in trouble
David Burns 9:31 PM
we’ve engaged @adamgoucher and he seems Ok, but this is where I want to get more usage from betas and the grid is pretty solid we’ve fixed the main issues from browserstack at least
Simon Stewart 9:32 PM
One thing I’d quite like is a way to hook in SaaS providers to the Grid
David Burns 9:32 PM
and I would love to get a new alpha out so we can start using Jaegar more
Simon Stewart 9:33 PM
The Docker support also needs some work Firebase support and XRay would be nice for use in GCP and AWS Our HTTP client needs work: I don’t think reactor is really going to work for us
9:34
Every time I try and switch to it, there’s Yet Another Weird Failure
David Burns 9:35 PM
I am happy to get Puja involved here
Simon Stewart 9:36 PM
I think one thing we’d really love to demo is “deploying Grid to EKS” and seeing it start outputting information @Puja Jagani’s help would be amazing
Puja Jagani 9:36 PM
Would love to help!
Simon Stewart 9:36 PM
Awesomeness :slightly_smiling_face:
Diego Molina 9:36 PM
we can do that, it should not be hard :slightly_smiling_face:
Simon Stewart 9:37 PM
Getting a Kafka version of EventBus would allow folks to use other hosted infra, but I think that may be too much for 4.0
Diego Molina 9:39 PM
I prefer to see the Gird being rock solid at its core, and when that is the case, add the other things
David Burns 9:39 PM
augementing things like that is a definite post 4.0 item
Diego Molina 9:39 PM
for example, I would say we can tackle the redis backed distributor after the release
Simon Stewart 9:40 PM
I’m working on some changes to make the state of the distributor serializable Once those are done, I’ll be a lot happier with it
Diego Molina 9:43 PM
Great, I think those are the topics for today, is there something else?
Simon Stewart 9:44 PM
Not from me
David Burns 9:44 PM
I’m done
Diego Molina 9:45 PM
Thanks everyone!
Simon Stewart 9:45 PM Thank you, @diemol!
At the Selenium project we practice
trunk based development, in which trunk
is the
usual name of the default git branch of the repository. However, when the project was
moved to GitHub, the repository followed the traditional use of master
as a name for
the default git branch.
With the intention of making the Selenium project an even more inclusive place where
everyone is welcome, a decision was made to use trunk
as the default git branch and,
after the switch, delete the master
branch. This change created a few challenges.
This blog post will point out a few things you should watch out if you want to make
the same change in your GitHub repository.
It is common to link specific parts of the code in the documentation, and that link
normally contains the branch name. Double-check your documentation for links pointing
to files living on the master
branch, as they could end up as broken links after
the change.
Similarly, the branch name gets mentioned in different parts of the repository, such as code comments, contribution instructions, issue and pull request templates, and the readme. Don’t forget to check these places.
We all like to show off how our GitHub repository is doing by adding as many badges as we can. In many cases, those badges report a build status that depends on the branch where the build was executed. Make sure your Travis/CircleCI/GitHub Actions badge is pointing to the new branch.
A good practice in open source is to have a continuous integration setup to run the builds, execute tests and potentially do automated releases. Nowadays, the CI configuration is done in files (e.g. .travis.yml for Travis), and one important piece of that configuration is the name of the branch where the build should be executed. Similar to the previous point, double check that your new branch name is property configured in your CI integration.
At the Selenium project, we have a few custom build scripts that get executed through the continuous integration setup. An example is the script that generates the docs for the Java, Ruby and Python bindings. This script needs to know the code’s branch name to generate the docs. If you have scripts with similar purposes, check them after changing the branch name.
All of the tasks above could probably be achieved with a text editor and a massive,
but careful, “search and replace” across all the files in the repository. In short,
the process we followed to move to the new branch trunk
was:
trunk
, based on the master
branch.master
branch.Nevertheless, one thing happened that we did not expect: after deleting the master
branch, all the open pull requests got closed. This made sense, since they were all
targeting the master
branch. Therefore, before deleting your master
branch, double
check and, if needed, edit the open pull requests so they target the new branch.
It goes without saying that the name of your new branch can be any name that works
well for your context and environment. For example, the
repository that has the
contents of the Selenium website uses now dev
as the
branch with the website source files and publish
as the branch with the generated
static website that gets published.
These are our lessons learned during the process of deleting the master
branch in
all the major repositories under the SeleniumHQ GitHub
organization. I hope they are helpful if you decide to move from master
as a name
for your default branch.
This was originally posted at https://opensource.saucelabs.com/blog/how_to_delete_your_master_branch/
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on August 13, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on August 27, 2020, 4:30 PM CET.
Diego Molina 7:58 PM :wave:
8:00 PM
Let’s start with the 1st item General project statistics (Previous meeting: 338 open issues, 73 open PRs)
8:01 PM
Current statistics 334 open issues, 63 open PRs Next item Overall announcements? New people on committees, with the commit bit, etc? Not that I am aware, anyone else?
David Burns 8:02 PM
No, but I would like to propose to create a new team on github for my team to at least have triage ability on bugs
8:03 PM
I can’t assign bugs unless they are somehow associated to the org
Diego Molina 8:03 PM
That is a good idea, I had the thought of creating a triage team and add people who are helping already in the #selenium channel, like @Salmon Mode :+1:
Simon Stewart 8:03 PM
+1 for a triage team
Diego Molina 8:04 PM
We should add that to the governance model
David Burns 8:04 PM
we can always discuss commit bit for my team at a later stage but I want them in the org
Diego Molina 8:04 PM
as a way to be part of the team without the need of explicitly be a committer
8:05 PM
who wants to take that task? add this to the governance model?
David Burns 8:05 PM
I can
Diego Molina 8:05 PM
:thumbsup:
8:06 PM
next topic? Improving workflow (Reviewing PRs, Improving design requirements)
David Burns 8:06 PM
that’s mine
8:07 PM
I would like to see if there is a way we can get designs for what people want descrribed better in issues I have noticed people misinterpretting requests in bugs that my team are working on
8:08 PM
and I dont know if it’s tribal knowledge that is missing or general experience or what can we get more definitive process for this
Simon Stewart 8:08 PM
“misinterpreting”?
David Burns 8:09 PM
well, we started down the observability issue and there are cases where work was done based on what their intrepretation was and it turned out to be different they didnt have the same context and motivation behind the changes
Simon Stewart 8:10 PM
It really helped when we had a conversation about the event stuff And since I’d planned to do that work myself, it seemed more lightweight not to fully describe everything in the issue
David Burns 8:10 PM
I agree, and I want to see if there are times we can front load that in to the issue rather than go down, write code , it’s wrong, try again
Simon Stewart 8:10 PM
Maybe if we make clear that they’re a placeholder for a conversation and identify who to speak to?
Diego Molina 8:11 PM
what I am missing in general about this, is that the decisions made through conversations in Slack are not being written in the GitHub issues or in the PRs, which makes things hard to review and move on
David Burns 8:11 PM
there is that too
8:12 PM
but having a converrsation requires the person that needs to be spoken to being free which isnt always a realistic expectation due to numerrous factors
Simon Stewart 8:13 PM
True, but front-loading all the design work is also impractical
David Burns 8:13 PM
I guess if we add more context and motivation that would be a good halfway point
8:13 PM
motivation being the main one for me.
Diego Molina 8:13 PM
what we also need to realise is that we did not have something that looked like a roadmap before, Simon helped with his brain dump that turned into the GitHub issues we have for the Selenium 4 release project so we are in a better place than the one we were but I agree that more detail on what is intended in the issues is needed, a natural next step in the iteration :+1:
David Burns 8:14 PM
agreed
8:15 PM
because, and this is my next item, if we can have some more info in issues it’s easierr to review there are changes that I can review and I go for correctness in the java server but it might be the wrong idea and we have PRs that sit, again due to people having lives and can’t always be here
Diego Molina 8:16 PM
do you think we should back to the open issues and find ways to extend them and make them more clear?
Simon Stewart 8:17 PM
Select the subset that are needing clarification and ask?
David Burns 8:17 PM
I have started doing that with some of the next load of work that I want my team to work on my goal, like everyone, is to ship se4
Simon Stewart 8:17 PM
Agreed And I want to help make that happen
8:18 PM
But I’m under some weird time constraints
David Burns 8:18 PM
I know, I am not blaming anyone
Simon Stewart 8:18 PM
I know :slightly_smiling_face:
David Burns 8:18 PM
I just want to make your life easier and my team’s and you’re kinda in both
8:19 PM
so… since code is mutable… can we go with I review for correctness, if it’s wrong and we spot then a new issue is raised with more context/motivation? and I will put it on my team’s stack?
8:20 PM
I feel this issue could raise it’s head with Sauce if they expand their team
Diego Molina 8:20 PM
uh, I need the simple English translation for that phrase
David Burns 8:21 PM
heh… sorry since I can review code, and make sure we have tests. If I feel it’s ok to merge I will, after a few days
8:22 PM
if others in this group disagree with the change, let me know, I will add it to our work and will get it sorted The issue of missing context and motivation could happen to anyone joining this group e.g. Sauce expanding their OSS team
Diego Molina 8:24 PM
got it, thanks for the translation I don’t see any issue with that, I think it makes sense in the end we can always improve things after merging code
David Burns 8:24 PM
cool. there are a few PRs from my team that have been sitting for a while
8:25 PM
and didn’t feel I could merge as I didnt have confidence in the serverr (give me a browser any day)
Diego Molina 8:26 PM
I am finding ways to help a bit more there, but we should follow your suggestion, I would appreciate a comment in the PR before merging it, like “hey, this has been sitting for while, it looks correct to me, I’ll merge it tomorrow unless someone has something against” :+1:
David Burns 8:27 PM
deal and we can get to a stage where my team can review each other which would be even better
Diego Molina 8:27 PM
:thumbsup:
8:28 PM
Next topic? Selenium Conf website in GitHub org? (README is pending)
8:29 PM
Quick update here, Andrew gave me an intro on how to make changes, the setup is more complex than I thought. We are in the process of documenting it. We should in the near future formalise a team in the governance model for the Selenium conference, there is a lot of work happening there that should be more recognised :+1:
8:30 PM
Next topic IDE to the main repo?
8:30 PM
I’ve seen @AutomatedTester and @rajendra moving the IDE repo into bazel, right?
David Burns 8:31 PM
bazel work is hand once that is done we can move it over wholesale I think the bazel work is 40% of packages. Tests still need doing but we’re touch the rough edges of bazel here
8:32 PM
we’ve both been chatting to people on the bazel slack
Diego Molina 8:32 PM
thanks for the update next topic?
8:33 PM
Users/passwords, access keys, etc… to distribution and release repositories. I added this one
8:34 PM
A few weeks ago I changed the way docker-selenium is released, moved it to GitHub actions, since I did not know the password used to push the images to Docker Hub, I had to reset the password and use it there
8:35 PM
which means that I am the only one who has the password now, and I believe this is the case for many other things we have (npm, python and ruby stuff, stores for Google/Firefox etc..) is there a way the ones in the TLC can have access to this information?
Simon Stewart 8:35 PM
We have some of the passwords stored in LastPass
Diego Molina 8:35 PM
and also consolidate it?
Simon Stewart 8:36 PM
We can share out individual credentials as needed
Diego Molina 8:36 PM
the thing is that the “as needed” moment usually comes when the one who has the credentials is not available
Simon Stewart 8:37 PM
That’s why we share them on LastPass :slightly_smiling_face:
Titus Fortner 8:37 PM
We could create a selenium account for Rubygems and share the password, right now it is giving individual accounts permission manually
Diego Molina 8:38 PM
Who has access to LastPass and can give access to all the TLC members?
Simon Stewart 8:38 PM
I do. Everyone in the PLC should have it too
Diego Molina 8:38 PM
I am only referring to credentials needed for releases and so on do we want to have different types of credentials mixed?
Simon Stewart 8:38 PM
(Sinking into a meeting where I need to talk at work. Dropping out of here)
Diego Molina 8:39 PM
Ok, then we can touch this topic again in the next meeting, but we already started it :slightly_smiling_face: Next topic: Anything new to report from the last PLC/SFC call?
8:40 PM
Seems not :slightly_smiling_face: Next topic: Conferences. Status for SeConf India & SeConf Chicago?
David Burns 8:42 PM
@mmerrell or @manoj9788 ?
Diego Molina 8:42 PM
I know India is virtual and there is a schedule already, I think they are figuring out if workshops will be done :+1::skin-tone-4:
Diego Molina 8:43 PM
and I saw that Chicago is officially postponed to 2021
David Burns 8:43 PM
in that case, move this topic to just india and then post that conference drop it from the agenda for a while
Diego Molina 8:44 PM
ok, makes sense next topic: Pending work that needs to be done for Alpha 7? Pending work that needs to be done for the first Beta? I am not sure if there are many updates here
8:44 PM
I think we need to land those PRs that are sitting to move to the last alpha
Marcus Merrell 8:46 PM
Yeah–we’ve moved out all SeConf Chicago meetings until November. We’re working to choose a new date with the venue for next year, and working on language in the contract that will allow us “ultimate cancel ability” if this thing continues to be a problem. We can move that off of the agenda for the time being :+1:
8:47 PM
I don’t have any new information about India - as far as I know there are no changes to the plan
Diego Molina 8:48 PM
thanks Marcus!
8:49 PM
So, I know that the 4 remaining topics in the agenda have no updates, so I suggest we skip them and we end the meeting early what do you think?
David Burns 8:49 PM
fine @mmerrell hey… friendly poke about that draining PR
Diego Molina 8:51 PM
ok, thanks everyone for your time!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on July 02, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on July 16, 2020, 4:30 PM CET.
Diego Molina 8:00 PM
Hi all, who is in for the Public Project meeting?
8:01 PM
8:02 PM
First, some project health: General project statistics Previous meeting: 343 open issues, 72 open PRs Now: 338 open issues, 73 open PRs
David Burns 8:03 PM
looks like healthy movement as I know I’ve handled a few issues and PRs personally
Diego Molina 8:03 PM
Next topic: Overall announcements? New people on committees, with the commit bit, etc?
Simon Stewart 8:04 PM
WebDriver BiDi meeting was yesterday. There’s some spec prose
David Burns 8:04 PM
@tourdedave is stepping back from the tlc, for a while at least unless I have misunderstood
Manoj Kumar Kumar 8:05 PM
@AutomatedTester stepping into TLC
Simon Stewart 8:05 PM
I thought he did that a while ago, but we failed to update everything
David Burns 8:05 PM
its more official :)
Diego Molina 8:05 PM
do we want to remove him from the list explicitly? does it make a difference?
Simon Stewart 8:05 PM
And @AutomatedTester should have been in the TLC from the start :man-facepalming::skin-tone-2:
“The list”? On the governance part of the site?
Yes
Diego Molina 8:05 PM
I thought @AutomatedTester was there, it just my mistake :slightly_smiling_face:
Simon Stewart 8:06 PM
Unofficial draft of the bidi spec: https://w3c.github.io/webdriver-bidi/ There’s a way to go yet
Diego Molina 8:06 PM
ok, I will create a PR to do that (removing @tourdedave)
David Burns 8:06 PM
As retribution for not being on the TLC officially you all owe me cake :cake:
8:06 :P as for the webdriver bidi, as @simonstewart said, there is prose.
8:07
yesterday’s meeting notes are in https://www.w3.org/2020/07/01-webdriver-minutes.html The spec is being driven by Mozilla and Google mostly atm
Diego Molina 8:08 PM
thanks for the updates next topic? Anything new to report from the last PLC/SFC call?
Luke Hill 8:08 PM
I’m just being nosy, nothing to see here.
Manoj Kumar Kumar 8:09 PM
Nothing specific from the last PLC/SFC call. We’ve caught up on conference updates, which we will cover shortly.
Diego Molina 8:10 PM
ok, sounds good next topic is: Did anyone talk to Miki about the go bindings?
Simon Stewart 8:10 PM
Nothing from me
Diego Molina 8:11 PM
ok the next topic is: Pending work that needs to be done for Alpha 7?
Simon Stewart 8:11 PM
I’d really like us to get the new UI in place for alpha 7 Even if it’s just a skeleton
David Burns 8:12 PM
That is in flight now, hope to get a demo on Monday and see what needs to be improved before we move into the repo :tada:
Simon Stewart 8:12 PM
Great news :slightly_smiling_face: Lemme check the project plan
Diego Molina 8:12 PM
I have seen CDP in Python and JS are almost there
David Burns 8:12 PM
we already have some of the parts required in master and the rest are being worked on CDP in python has landed
Simon Stewart 8:13 PM
https://github.com/SeleniumHQ/selenium/projects/2
Manoj Kumar Kumar 8:13 PM
And GraphQL is nearing completion, I guess.
Simon Stewart 8:13 PM
Things on my list are the new features based on CDP usage Pluggable locators
8:14
And CDP/WebDriver interop (mostly at the element and window level) Those will let us call alpha 7 the final alpha :tada: And we can make a start on the betas as we’ll be feature complete IMO Anything else that folks can think of?
Diego Molina 8:15 PM
nothing else from my side
David Burns 8:15 PM
we do have the beta list at https://github.com/SeleniumHQ/selenium/issues?q=is%3Aopen+is%3Aissue+label%3ASelenium-4-Beta
8:16
do we need to move more things there?
Simon Stewart 8:16 PM
Are those “bugs to fix in the betas” or “bugs to fix before we can cut a beta”?
David Burns 8:16 PM or remove yes
Simon Stewart 8:16 PM
Logically correct, but not an actual answer :slightly_smiling_face:
David Burns 8:16 PM
it’s a list of things @diemol thought we needed and I mostly agree
Diego Molina 8:17 PM
they come from the Google Doc we went through in London in February with Simon
Simon Stewart 8:17 PM
I shall ruthlessly reprioritise Those are things that we mostly need in place before release
8:18
But I think we can go into the betas with “the features are there, but they’re known to be unstable” The alphas are “the features aren’t even there yet”
Diego Molina 8:18 PM
I would expect to have a few things being unstable in the betas
Simon Stewart 8:19 PM
“A few things” will definitely be unstable
David Burns 8:19 PM
I would like to get things that may have got sorted but the bug list is out of date sorted as well from our lists
Simon Stewart 8:20 PM
That list seems mostly up to date
David Burns 8:20 PM
but things like Ruby on bazel and ide in the mono repo I dont think are Se4 dependent
Simon Stewart 8:20 PM
I don’t see things that are already fixed in it
David Burns 8:20 PM
my comment was general so people checked :D
Diego Molina 8:20 PM
indeed, I usually keep an eye on the issues, and I believe is up to date btw, we are already covering the next topic in the agenda Pending work that needs to be done for the first Beta? :+1::skin-tone-4:
David Burns 8:21 PM
yes and no… Can we get PRs in flight finished if they are just waiting on reviews on fixing review comments I meant
Simon Stewart 8:22 PM
Which ones in particular?
David Burns 8:22 PM
The draining one and the redis one (not picking on people) come to mind
Simon Stewart 8:22 PM
I’m not happy landing the Redis one since it leaves a broken RedisBackedDistributor in the tree, and that’s suboptimal
8:23
I need to re-review the draining one
David Burns 8:23 PM
I am not saying we need to fix it but we need people to finish them off :)
Simon Stewart 8:23 PM
Indeed.
Diego Molina 8:25 PM
so, is there anything else to add before moving to the next one?
Manoj Kumar Kumar 8:25 PM
Selenium IDE work is a separate topic? Unsure if @corevo is here? I meant on the Electron piece of work.
David Burns 8:25 PM
I can field that…
Manoj Kumar Kumar 8:25 PM
great!
David Burns 8:26 PM
Selenium IDE is now in the Edge store :tada: that’s the extension version
8:27
As for the electron version, that’s slightly on hold atm but hopefully we can start that up soon :+1::skin-tone-4:
Manoj Kumar Kumar 8:27 PM
https://microsoftedge.microsoft.com/addons/detail/selenium-ide/ajdpfmkffanmkhejnopjppegokpogffp Link to MS Edge store
David Burns 8:27 PM
I would like it to be a thing as we work on core “fit and finish” pieces
Diego Molina 8:28 PM
sounds good should we move to the next topic?
Manoj Kumar Kumar 8:28 PM
yes
Diego Molina 8:28 PM
Conferences. Status for SeConf India & SeConf Chicago?
Manoj Kumar Kumar 8:29 PM
SeConf Chicago - Postponed to 2021 - we are working on new dates and Hotels.
8:30
SeConf India - It was supposed to held on June - we’ve moved it to September, but it seems hard and the Indian borders won’t open up for any travels in and out.
8:31
Final decision is yet to be made, it will get postponed or we may have a shortened(online event)
Diego Molina 8:32 PM thanks for the updates :slightly_smiling_face:
Manoj Kumar Kumar 8:32 PM
@mmerrell Please fill in, if I’ve missed anything!
Diego Molina 8:32 PM
next topic is: Selenium Conf website in GitHub org? @andrewmkrug did a great job in revamping the site weeks ago, and now the code is in a private repo under the SeleniumHQ GitHub org he’ll add some instructions to the README on how to develop on it and deploy it :clap::skin-tone-4:
8:34
the repo is private just to keep information about future conferences confidential :slightly_smiling_face: next topic: IDE to the main repo?
David Burns 8:35 PM
No change on this. I hope to get to it soon, I have a branch doing the Bazel work
Diego Molina 8:35 PM
ok, sounds good next topic: CoC, next steps?
David Burns 8:36 PM
Last week @diemol and I met with Sage Sharp and had a productive meeting
We have given them a bunch of details and they hoped to get back to use end of this week or beginning of next week with a draft
Diego Molina 8:37 PM
yeah, it was a great session, and I think the CoC is on a good path
Marcus Merrell 8:38 PM
The only conference-related note is that we’re looking at a potential opportunity to host an online-only conference sometime in September/October, but we don’t have details or info on the $$ piece yet
Diego Molina 8:39 PM
thanks @mmerrell
8:40
should we move to the next topic?
David Burns 8:40 PM
regarding online confs I would like people to speak to their respective marketing companies and see if it’s being over done
Marcus Merrell 8:40 PM
that’s my #1 concern
David Burns 8:40 PM
there are so many atm…
Marcus Merrell 8:40 PM
how’s Breakpoint looking, btw?
David Burns 8:41 PM
It’s good so far but I know marketing team don’t really want anything past that
Marcus Merrell 8:41 PM
right… not surprising
David Burns 8:41 PM but that may change
Marcus Merrell 8:42 PM
@simonstewart was talking about potentially having a webinar series instead of a 6-hour block of content, and I’m kind of interested in anything that will keep the zoom fatigue to a minimum
unfortunately, online conferences are not my thing, as an organizer or a participant… this might make me an ideal candidate to create an event that won’t over-do it
David Burns 8:42 PM
heheh
Diego Molina 8:43 PM
ok, seems we can move to the next topic
Selenium Branding guide
Manoj Kumar Kumar 8:44 PM
We’ve always get many requests on usage of Selenium Logo for multiple purposes, PLC usually respond to those requests with the help of SFC folks.
And there is also an issue to track : https://github.com/SeleniumHQ/seleniumhq.github.io/issues/81 This has been long pending and finally we’ve started with it…
8:45
Selenium Branding guide is in-progress. Its on a private Google doc shared with the PLC and TLC members. The legal rep from the SFC team has reviewed and shared feedback and recommendations. And right now its with our Selenium team (PLC, TLC(may not be all of TLC) to look at it and see if we need more clarifications.
8:46
@simonstewart @diemol @AutomatedTester and others When you get a moment, pls take a look and share your feedback
Diego Molina 8:47 PM
I think it makes sense to have something like that, it is easy to see the Selenium logo / name misused in many places
that’s a good initiative @manoj9788!
David Burns 8:47 PM
What does this mean when people use our brand incorrectly. Like there is a linkedin group that charges for people making specific posts there.
8:48
(from what I am told) do we have recourse to challenge them?
Manoj Kumar Kumar 8:49 PM
That reminds of another questions,What are social media accounts that are handled by SeleniumHQ team?
Marcus Merrell 8:49 PM
using it to promote “Selenium Certification” is the example I see most often I believe we’ve done it before (before I joined the PLC) “done it” == “challenged them”
Manoj Kumar Kumar 8:50 PM
AFAIK, Twitter: SeleniumHQ, SeleniumConference are handled by SeleniumHQ team. LinkedIn: Is there one? Facebook: I think there is one, but don’t think anyone from SeleniumHQ team is handling that.
Marcus Merrell 8:51 PM
we should hire a tween to manage our insta (and TikTok) only half-kidding
Diego Molina 8:51 PM
there is this https://www.linkedin.com/company/selenium/about/ and this https://www.linkedin.com/company/selenium/about/
Marcus Merrell 8:51 PM
especially considering how many tweens use Selenium to do fortnite/roblox stuff
Manoj Kumar Kumar 8:51 PM
TikTok is officially banned in India :slightly_smiling_face:
Marcus Merrell 8:51 PM
lol
Diego Molina 8:52 PM
sorry, the 2nd link was meant to be this one https://www.linkedin.com/groups/961927/ (edited)
Manoj Kumar Kumar 8:52 PM
ok, no politics here. No idea, who owns that.
Diego Molina 8:54 PM
I feel this topic overlaps with the last one in the agenda: Selenium marketing strategy (e.g: Webpack)
Manoj Kumar Kumar 8:55 PM
Diego you could share some insights on the example you gave on Webpack
Diego Molina 8:56 PM
yeah, I was trying to find some info while Googling
8:57
the idea I heard, is that webpack was not having a good moment in terms of users and reputation and revamping their image (docs, social media, and of course improving the project code) helped them enormously so this point is just to have a conversation starter and see if you think something similar makes sense for Selenium
Simon Stewart 8:58 PM
It’s useful. I think we should also take a look at the things that people like about Cypress and make it clear how to surface the same thing in Selenium :+1::skin-tone-4:
Manoj Kumar Kumar 8:59 PM
Agreed! I think it makes sense @diemol
David Burns 8:59 PM
I would love for us to do something here. @simonstewart and I have previously discussed this as “fit and finish”
9:00
these are the things that people like about puppeteer/cypress and we’ve not done a good job of explaining similar things
Simon Stewart 9:01 PM
Indeed. TBH, I thought we’d be done with Se4 at this point And well into the fit-and-finish bit that could be Se5 But I agree with @diemol that part of that is a nice site with excellent docs
Diego Molina 9:02 PM
nice, so it seems there is a general feeling that we should be doing something like that I can try to do something about it and give an update for the next meeting
Simon Stewart 9:02 PM
Just one piece isn’t good enough to solve the problems That’d be fantastic, @diemol
Manoj Kumar Kumar 9:02 PM
Happy to pair on that @diemol
Diego Molina 9:02 PM
sounds good!
9:03
well, that was the last topic in the agenda, and we are 3 minutes past the end of the meeting thank you everyone!
David Burns 9:03 PM
yay
Manoj Kumar Kumar 9:03 PM
And we’ve moved from Master to Trunk Thanks @AutomatedTester
David Burns 9:03 PM
yes, and it was an important move
Manoj Kumar Kumar 9:04 PM
Thanks @diemol @simonstewart @AutomatedTester and everyone!
master
branch in favour of trunk
Since the project started we have been following trunk based development. This was a very natural fit when we were using SVN over a decade ago on Google Code.
As Google Code shut down we moved to GitHub and the git model of doing things. We moved there mostly due to the gravity that GitHub had created in Open Source projects.
This meant that we followed the standard use of master
as our trunk to work off. Now that GitHub, and services that use GitHub, have improved support for non-master branches as default we are moving our default branch to trunk
. It describes how we, as a project, work and is a more inclusive term.
If you have pull requests based on master
we will see about moving that over to the trunk
branch ourselves. If we can’t, we may ask you to help with the rebasing.
We, as a project, want to make our community inclusive and this is just one step in making sure we are. Other steps we taking are improving our Code of Conduct and Community Guidelines.
Join us on Slack or IRC if you wish to discuss this further.
After an interaction on the last weekend of January 2020, on a Selenium Issue where someone said “why can’t you just…” after I explained the issue I thought that I would start explaining commands in Selenium WebDriver and why we landed on the design that we have today.
I will repeat this on every page of the series but a lot, an annoying amount sometimes, of thinking goes into how every little bit of Selenium works.
Why?
Selenium, by chance and being good at what it does, is used by millions of people around the world as well. It’s how companies from Microsoft and Google to the small startup make sure that their site works in every browser.
Selenium, over the years, decided that we were going to use HTTP to speak to the browser. We built a REST-ish API that every client binding could use and hopefully get the same results.
Yea…
Let’s start with the HTTP part. When we started we had to have a unique way to speak for each browser based on the best way to speak to them. So for Internet Explorer we wrote COM code. It was fine, it worked but gave us nightmares. For Firefox we wrote a monstrocity that read line by line and, thankfully, due to Mozilla’s “make the browser yours” attitude we could do a lot. Opera allowed us to go in via the DevTools protocol.
Now, it meant that, especially in the early days of WebDriver, we would need to maintain N: M bindings where N is the language bindings and M is the browsers we support. This is not a road to a good product. We decided that we need something that every language would understand. We also needed something that would be pretty robust. HTTP was chosen and we set about building the JSONWireProtocol
.
The JSONWireProtocol
is where we built a REST-ish interface that would speak JSON. I say REST-ish because it didn’t follow all the principles of REST but enough to make it powerful for our needs.
The Web, the internet, and the world has moved on. Why hasn’t Selenium?
This is a good question and the thing is we are trying to move things on. Unfortunately the web has a state where it is broken unless it is working. HTTP is pretty robust as a protocol. It can also allow people to build up clusters for testing without having to worry too much about how the multiplexing would work. This is the reason why Selenium Grid was created and is still a pretty good choice when it comes to farming out your testing to multiple devices and multiple machines.
So… There are tools that use Chrome’s Debug Protocol to drive the browser and some of the things they do better than Selenium are down to their choice of how they speak to the speak to the browser. Unfortunately it’s a Chrome proprietary protocol and Google is not interested in working with other browsers on making it not.
Also, ignoring the interesting design choices from the the Google team, there is the problem that we have to have a permenantly open connection. In this case it uses WebSockets but if you remember my comment earlier about the internet is down until it’s up. WebSockets would be constantly re-establishing the connection. There is also the problem of how much traffic would be going up and down that pipe.
This is fine for puppeteer where you are only speaking to something on your local machine but if you are combining a CI service, like Circle CI or TravisCI and something like AWS Device Farm, Sauce Labs, or BrowserStack you suddenly have a lot of internet inbetween you and your runner and that data needs to get somewhere.
The W3C Browser Testing and Tools Working group, which is made up of browser vendors and Selenium folk, are trying to design what this will look like to make sure that we can make it cross browser from the start without having to do weird hacky patches to browsers and ship those browsers ourselves.
This was originally posted to https://www.theautomatedtester.co.uk/
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on June 04, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on June 18, 2020, 4:30 PM CET.
Diego Molina 8:05 PM
the agenda will be:
Simon Stewart 8:06 PM
Hahaha
Agenda item: path to betas
8:07 I’d like to hear about the work that @AutomatedTester has in mind for his interns, and how (as a project) we’ll support them
Diego Molina 8:08 PM
Agenda:
Let’s start
8:09 general project statistics: two weeks ago: 391 open issues, open pull request: 68 now: 343 open issues, open pull request: 72
8:10 looking better, let’s keep the pace! 1
next item:; any overall announcements? new people on committees, have the commit bit, etc?
Simon Stewart 8:11 PM
Just a quick note that @Bongosway has landed a few patches recently. I’m hoping that we find a way to help him into the fold a little more
And a high five to @rajendra for his work on the JDBC stuff 1 reply 4 days ago View thread
Diego Molina 8:12 PM
absolutely, thanks for contributing!
anything else or should we move to the next item in the agenda?
8:13 ok, next item: what do we need to be done before doing Alpha 7?
Simon Stewart 8:15 PM
Things I’d like to see:
Of which that last is in my court
David Burns 8:16 PM
as for my interns, one of which in here so say hi to @Saksham Gupta
Simon Stewart 8:17 PM
waves to @Saksham Gupta! 1
David Burns 8:17 PM
They will be extending the GraphQL system with in grid (@Saksham Gupta )
and Phani, when he joins, will be building out the Grid UI and modernising it
Diego Molina 8:18 PM
that sounds great!
Marcus Merrell 8:18 PM
welcome, @Saksham Gupta! 1
David Burns 8:18 PM
The goal of the work is to add most, if not all, the features we want in this area
8:19
both @Saksham Gupta and Phani will be supported by me and @rajendra
8:20
and next week we have another member joining our team who we can get to support both interns to make sure we don’t have any performance hits with the work they add and guide them through perf profiling. etc
Simon Stewart 8:20 PM
@Saksham Gupta you might find this useful: https://docs.google.com/document/d/1aFMmmMhBg1PgfTPmyaXaEJAhsh0lf3p0VpV7kfHIstI/edit
Diego Molina 8:20 PM
anything else pending from the non-Java stuff?
I know CDP is not working with JS yet, not sure about Python
David Burns 8:20 PM
Non-java we need to add CDP to python and JS which my team will be doing
Simon Stewart 8:21 PM
One thing i’m keen on is steering users away from raw CDP
David Burns 8:21 PM
agreed
Simon Stewart 8:21 PM
When we get WebDriver BiDi in place, we’d like to use that where possible
CDP is ugly, hard to use, and deeply fragile
Diego Molina 8:22 PM
that is a good point, because we don’t want GitHub issues reporting bugs merely due to something failing in CDP
Simon Stewart 8:23 PM
Something will fail with the CDP stuff
I may have to version it independently of the rest of the java pieces.
Diego Molina 8:23 PM
is the idea to have CDP in JS and Python for Alpha 7?
Marcus Merrell 8:23 PM
has the chromium team talked at all about CDP becoming a standard, or publishing a roadmap? (I’m off to put this exact question into google)
Simon Stewart 8:24 PM
They’re involved with the webdriver bidi stuff
I think there’s a lot of value separating “automation” from “debugging APIs”
Marcus Merrell 8:24 PM
yeah
David Burns 8:24 PM
the spec is being worked on right now
I have been reviewing it this week
Marcus Merrell 8:24 PM
I saw the transcript from last week, good stuff
David Burns 8:25 PM
CDP is not going to be the standard
Diego Molina 8:25 PM
asking again to stay in the topic, is the idea to have CDP in JS and Python for Alpha 7?
Simon Stewart 8:25 PM
Yes
David Burns 8:25 PM
@diemol maybe.. hopefully
Simon Stewart 8:25 PM
We need all languages to have that in place before we can move to betas
Diego Molina 8:27 PM
I have seen a few PRs from https://github.com/seanpoulter, he seems keen to help in JS he already asked how he can implement relative locators in JS we should try to give him quick feedback
Sean Poulter Location Ottawa, Canada Repositories 22 Followers 17 @seanpoulter | Oct 18th, 2012 | Added by GitHub
Simon Stewart 8:28 PM
@harsha509 would you like to help with that? Or @corevo?
And
David Burns 8:28 PM
JS relative locators is in there, might need some TLC
Sri Harsha 8:28 PM
i need a week to hack into js things. currently busy in paid work
Simon Stewart 8:28 PM
NP.
8:29 These paid jobs are what allow us to have the luxury of working on OSS. Focusing on them makes a lot of sense
Diego Molina 8:29 PM
in any case, let’s try to give feedback, we are in the look for JS maintainers and who knows if he could be “the one”
ok, next item?
Simon Stewart 8:30 PM
Have we finished the beta discussion?
I don’t think we’ve got more items to add to it
Diego Molina 8:31 PM
no, that is next
Work to be done before beta? (Path to betas)
Simon Stewart 8:31 PM
The things for alpha-7 are the blockers for beta
8:32 After that, I think the changes are incremental rather than entirely new features
8:33 (other than (maybe) pluggable locators0
Marcus Merrell 8:33 PM
also my “drain” feature
I’m negotiating a couple days with my paid work to get back on that
Simon Stewart 8:33 PM
That’d be nice to get into a7
I suspect that the graphql stuff will cause some changes to have to happen
Marcus Merrell 8:33 PM
can we set up a time to pair for an hour or so?
Sri Harsha 8:33 PM
I will take over maintaining JS bindings for sure in future
Simon Stewart 8:33 PM
@mmerrell sure
8:34 I’m around monday and tuesday next week
@harsha509 WOOHOO!
That’d be awesome
Marcus Merrell 8:34 PM
perfect–I’ve just blocked out most of the day for it
I know what I need to do, but would like a bit of validation on the approach, and then I need to test it
Diego Molina 8:36 PM
ok, seems the betas part has been mostly discussed in the Alpha 7 part and these previous lines
if everyone is ok with it, next topic 2
when is the next SFC call? (if its happened in the last two weeks, anything to report)
Marcus Merrell 8:36 PM
it happened Tuesday, and I believe we primarily discussed the conference
Diego Molina 8:38 PM
ah perfect, there is an item in the agenda for “SeConf India SeConf Chicago”
Simon Stewart 8:38 PM
@manoj9788 will know the most about that
Marcus Merrell 8:40 PM
yep
Diego Molina 8:40 PM
is there something else to comment from SFC or conferences? or should we move to the next item?
Marcus Merrell 8:40 PM
I can speak for Chicago
I don’t think we talked about anything else… the SFC wasn’t present on the call
Diego Molina 8:41 PM
would you like to say something about the Chicago conference?'
Marcus Merrell 8:41 PM
yeah–we’re negotiating with the hotel to take our contract and move it to 2021, around the same time of year
8:42
we’re waiting to hear back from them with a selection of dates in the Sep-Oct-Nov range
hoping not to have it the week before Thanksgiving, but also hoping to keep the room rates low
8:43
as to this year, we’re talking about holding a very sane, relatively small virtual conference, or a series of webinars spread over a couple months
we’re also discussing having another group help us out with planning and execution, someone with experience at promoting and running virtual conferences
8:44
the first discussion will happen today, and if we decide to explore further, I will probably feel more comfortable talking about who we’re considering
there is a lot to consider for a virtual conference, and we want to make sure we are thoughtful and careful
Rajendra Kadam 8:44 PM
replied to a thread: And a high five to @rajendra for his work on the JDBC stuff Thanks @simonstewart. . It wouldn’t have been complete without your help. 1
Diego Molina 8:44 PM
all that is already a lot of info, thanks for sharing!
Marcus Merrell 8:45 PM
for SeConf India, I don’t know if @manoj9788 is on and would like to share. If not, I can at least say a little about what they’re considering, I just don’t want it to be incomplete
Diego Molina 8:46 PM
up to you I would say
Marcus Merrell 8:48 PM
it appears that there’s no way they’re going to be able to put on a conference in September in Bangalore. The borders and COVID caseload aren’t adequately under control, and much like the US conference, there are too many variables that would need to be under control right now for Naresh to feel confident about having an in-person conference a scant 3 months from now 1
(by “borders” I mean “international travel & quarantine procedures”)
Diego Molina 8:48 PM
that makes a lot of sense
Marcus Merrell 8:50 PM
so we are discussing whether or not we can essentially combine the notion of a virtual conference. That troubles me because I know that all parties involved want to see revenue, but the Selenium project doesn’t want to charge for admission. I’m concerned there would be too many hands in the pot for any one of them to receive enough $$ to make it worth their while
but that’s my own concern–not meant to represent the opinion of the planning committee. We’re looking for data, not opinions–so we’re reaching out to people who have been through this in recent weeks to find out what’s possible
8:51 we hope to report in a couple weeks on any progress, both with planning the virtual conference, and with whether or not we can expect to fund our coffers in the near future
Diego Molina 8:51 PM
ok, then we can follow up in the next meeting, thanks! 1
8:52 next topic: Did anyone pick up the ball to talk to Miki about the go bindings?
Simon Stewart 8:52 PM
Not me
Diego Molina 8:52 PM
I think no one did but we should keep the topic around, and try to get to it when we have Se 4 released or close to be released
8:53 adding one more binding now would be too distracting which does not mean that we cannot reach out to him
Simon Stewart 8:54 PM
Agreed
Diego Molina 8:55 PM
ok, let’s move to the next one since we only have a few minutes left
Selenium Conf website in GitHub org?
I see the site was revamped, so great job @andrewmkrug
8:56 but I am not sure if @andrewmkrug is having problems to push the code to the org I can reach out to him
Simon Stewart 8:56 PM
Thank you 1
Diego Molina 8:56 PM
next topic: IDE to main repo?
8:57
I guess we should focus more on the bindings and the Grid for now?
Simon Stewart 8:58 PM
I think @AutomatedTester has already done a chunk of the heavy lifting
9:00
Got to go. Meeting time
Diego Molina 9:00 PM
last topic was CoC, but we can take it next time
well, we covered everything (almost), thank you everyone! 1
Marcus Merrell 9:01 PM
thank YOU, @diemol 1
We are very pleased to announce the release of Selenium 4.0 Alpha 6.
All the information can be seen in different tweets from the project contributors, here they are all in one place:
Happy Friday! I've just pushed Selenium 4.0a6 for Java. There's a lot of nice changes:
— Simon Mavi Stewart (@shs96c) May 29, 2020
* Full remoting of the CDP protocol across the Grid
* The skeleton of our GraphQL support
* Better configuration options, especially for Nodes, via TOML
* A bajillion improvements & fixes
1/5
As ever, this release is the product of hard work and contributions not only from the core team (special thanks to @barancev and @diemol. You've done amazing work!) but also from a host of other people. In that spirit, I'd like to thank… 2/5
— Simon Mavi Stewart (@shs96c) May 29, 2020
In no particular order:
— Simon Mavi Stewart (@shs96c) May 29, 2020
* Amit Bhoraniya
* @bongosway
* Gerry Gao
* Sridhar Upputuri
* John Chen
* @alb_i986
* Rahul Shah
* @ulfjack
I've linked to the twitter handle where I know it. Give 'em a high five! Selenium wouldn't be possible without the help of the community! 3/5
I'm hoping that the next alpha will be the last alpha. The "big ticket" items remaining are:
— Simon Mavi Stewart (@shs96c) May 29, 2020
* Provide nice APIs to take advantage of the CDP
* Flesh out the GraphQL support
* A nice UI to take advantage of the GraphQL endpoint
* Robustness work in the Grid
4/5
You can come and join in the fun by either heading over to the GitHub project and picking a task (https://t.co/2ifj6CkeEV) or (and!) coming to have a chat on Slack https://t.co/4aEDqyI6gq 5/5
— Simon Mavi Stewart (@shs96c) May 29, 2020
I have just tagged #Selenium 4a6 on GitHub. It's got a lot of nice cleanups as we edge closer to a proper #Selenium 4 release!
— David @automatedtester@mastodon.social (@AutomatedTester) May 28, 2020
selenium-webdriver 4.0.0.alpha6 has just been released. The biggest change is an experimental support for Chrome DevTools protocol! Read more in changelog https://t.co/1l2XYkaEfB.#selenium #ruby #devtools
— Alex Rodionov (@p0deje) May 28, 2020
Happy hacking!
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on May 07, 2020 (times are on IST).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on May 21, 2020, 4:30 PM CET.
adamgoucher 8:00 PM
alright. welcome back. time for another fortnightly chat about the project.
Simon Stewart 8:01 PM
:wave:
Diego Molina 8:01 PM
:wave:
Sri Harsha 8:01 PM
:wave:
adamgoucher 8:02 PM
some general project statistics; open issues: 391 open pull request: 68 (which is the lowest i think ive seen either of those numbers before)
8:03
agenda wise, this is going to be more loosey-goosey than normal as i’m swamped with day job so ignoring things. we’ll see is that is a good thing or not.
8:03
any overall announcements? new people on committees, have the commit bit, etc?
Simon Stewart 8:04 PM
I’ve landed the update to OpenTracing, which unblocks me
8:04
Next step is to wire the tracing into the Docker support And then pick up the websocket forwarding
8:05
(Which, to be fair, is “mostly done”)
adamgoucher 8:05 PM
heh. the last 20% takes the other 80% of the time :slightly_smiling_face:
Simon Stewart 8:05 PM
The Pareto Principle in action
8:06
I’d be happy pushing a6 before the next meeting
adamgoucher 8:06 PM
what do we think is missing from a6 now?
Simon Stewart 8:06 PM
It’s been a while since we did a release, and there’s progress in there
8:07
I’d dearly love the websocket forwarding, but I can live without it @diemol landed the first work with Fail Safe for some more robustness in the Grid
8:08
I think @barancev is also making some progress switching the underlying HTTP engine again
adamgoucher 8:08 PM
looks like there was a bunch of plumbing / dependencies updated in the last week especially with .net and python
Simon Stewart 8:08 PM
@jimevans and @AutomatedTester know more than I do
Jim Evans 8:10 PM
yes, the .NET bindings build using bazel should now work cross-platform. you should be able to run .NET tests using bazel test (with caveats, which i’ve yet to fully document). it kinda works within VS code, but one can for certain develop using Visual Studio 2019 on Windows, and Visual Studio for Mac on MacOS.
adamgoucher 8:11 PM (still breaks my head to write .net code on mac)
8:11
what more was needed for the http engine stuff? i thought there was a flag in there already?
8:12
or did we change it again, again
Simon Stewart 8:13 PM
The underlying library didn’t support http/2 or unix domain sockets, despite it being possible
adamgoucher 8:14 PM
so do we want/need to wait for that work to be done-ish before doing a6? so far that sounds like the only thing that will be confusing to release partially implemented
Simon Stewart 8:14 PM
Nah.
adamgoucher 8:15 PM
scans commits in another window
Simon Stewart 8:15 PM
As long as it’s in before we start on the betas, we’ll be fine
adamgoucher 8:15 PM
a question i know we dont have an answer for, but do we have a gut feel for how many more a’s there are before we start the b’s?
Simon Stewart 8:16 PM
The major outstanding features are: websocket forwarding graph-ql support
adamgoucher 8:16 PM
thats not that horrid of a list. its been much worse
Simon Stewart 8:17 PM
We’ve been chipping away at it
adamgoucher 8:18 PM
so if a6 is within the next 2 weeks, do we have a trigger condition for releasing it?
Simon Stewart 8:18 PM
No trigger condition
8:18
Other than “someone updates the changelog”, I guess
adamgoucher 8:19 PM
do we want to say ‘a6 is next tuesday’ so that all the maintainers are ready to build and tag everything? (feel like we can’t magically do it all from ci but could be making that up)
Simon Stewart 8:20 PM
The graphql piece is to support the ui, so strictly speaking we don’t really need it, but it keeps things flexible
8:20
@AutomatedTester, @p0deje, @jimevans, @titusfortner, @harsha509 Cool with shipping an alpha next week?
Jim Evans 8:21 PM
+1 from me.
Sri Harsha 8:21 PM
Yes
Diego Molina 8:22 PM
how are we handling the numbers in JS, JS is already in a7, right?
Simon Stewart 8:22 PM
“alpha-n+1”
Sri Harsha 8:22 PM
Yes @diemol . Do you have any suggestions @corevo . He should be releasing the next alpha as i know.
Alex Rodionov 8:23 PM
+1 from me
Tomer Steinfeld 8:25 PM
JS has been in alpha for a long time because of historical reasons
adamgoucher 8:25 PM
ok. so thats covers the bulk of the pressing tech stuff. other stuff that could be discussed; when is the next sfc call? (if its happened in the last two weeks, anything to report) did anyone pick up the ball to talk to miki about the go bindings? seconf india seconf us state of the se-ide into the main repo
Tomer Steinfeld 8:25 PM
I think we can land stable 4.0 together, but I don’t see a reason we should release 4 alphas together
adamgoucher 8:26 PM
(or we can keep talking about js too. but that list is just my remaining things)
Marcus Merrell 8:26 PM
the PLC call happened on Tuesday, it was just me and Jim. We mostly talked about conferences, and we were going to follow up with Simon about the status of the Code of Conduct
Simon Stewart 8:27 PM
Uhh… I thought @AutomatedTester was running with the CoC stuff.
Marcus Merrell 8:27 PM
at this point India is still slated to happen in September, same venue. I don’t know the latest about speakers or progress or anything like that
Simon Stewart 8:27 PM
It’s entirely possible I am mistaken
adamgoucher 8:27 PM
i thought david was on that too
Tomer Steinfeld 8:27 PM
Is there an update from the SFC about the MS store?
Marcus Merrell 8:28 PM
ok, I thought David was on the MS Store issue, and not the CoC, but it wouldn’t be the first time I was mistaken
Diego Molina 8:28 PM
why don’t we take the CoC draft we have, add it to the new site, and iterate on it?
Simon Stewart 8:28 PM
We were going to get a review and some guidance from Sage Sharp
Marcus Merrell 8:29 PM
for Chicago, we’ve got a verbal understanding that the venue will allow us to reschedule the conference for sometime next year with no fees. We’ve already given them a somewhat hefty deposit, and while we could likely fight to get that back, we’d rather just have it next April or October–we’re going to make that decision in late May/early June
Diego Molina 8:30 PM
for the SeleniumConf website, @andrewmkrug has joined the Selenium GitHub org, and he is helping us to push the site code to a private repo
Marcus Merrell 8:30 PM
for the Fall, we’re considering an online-only conference, and we’re waiting for a few pieces of data to come in over the next couple weeks, around TestBash and SauceCon, to gauge how they went, ideas for optimization, pros/cons, do’s don’t’s, etc
Andrew Krug 8:30 PM
was added to #selenium-tlc by Diego Molina.
Marcus Merrell 8:32 PM
I spoke to Deb (from SFC) quite a bit on Friday about tips and pointers for an online-only conference, and I’ve started to develop some opinions for how it should be done. I haven’t yet, however, come up with a firm position on the pricing model for sponsors or attendees–I definitely want to offer all the track sessions/keynotes for free, and offer a paid tier for “something” else, like if people want T-shirts or something else, but it would likely be a model where they pay what they want (to support the project), and the swag they get depends on the tier they buy into
8:33
I’m waiting to hear more from Richard Bradshaw before beginning that discussion, probably during our bi-weekly Conference conference call, on May 28th
adamgoucher 8:35 PM
so. CoC — when can we get the review and guidance? if its more than ‘not in may’ we should likely throw it up and start the iteration process
Simon Stewart 8:36 PM
It depends on Sage’s availability, and that of the people working on the CoC
adamgoucher 8:37 PM
(which, sounds like we’re not quite sure of who those are from our end)
Simon Stewart 8:37 PM
Last I checked, @mmerrell, @AutomatedTester, @diemol, @jimevans and I were all interested in being involved
8:38
From memory.
adamgoucher 8:38 PM
so the nebulous items seem to be; determine who is actually on the coc stuff
Simon Stewart 8:38 PM
Agreed
adamgoucher 8:38 PM
doh! no editing. and, determine who is actually doing the ms store stuff
8:40
which means, for the next meeting;
8:41
anyone else have anything they want / need to discuss in public?
Simon Stewart 8:41 PM
I’m good
8:41
Though perhaps we should figure out who owns what on that list I hold the build bacon this time
Diego Molina 8:42 PM
maybe we can record how a release is done? and from that I can write docs
Simon Stewart 8:43 PM
I’ll walk you through the process We did have it written up here: https://github.com/SeleniumHQ/selenium/wiki/Releasing-Selenium
adamgoucher 8:43 PM
from the april 23 meeting, looks like @AutomatedTester is the store person Screen Shot 2020-05-07 at 11.12.57 AM.png Screen Shot 2020-05-07 at 11.12.57 AM.png
David Burns 2 days ago
I am waiting on replies from SFC. I chased up yesterday. Have meeting with MS next week
adamgoucher 8:45 PM
anyone volunteering for CoC lead?
Diego Molina 8:46 PM
ah nice, the release process is written, we “just” need to update it
Simon Stewart 8:46 PM
The java one doesn’t seem wildly inaccurate
adamgoucher 8:48 PM
which means, for the next meeting;
Alexei Barantsev 8:49 PM
sorry to be late, I’m +1 for the next alpha
adamgoucher 8:50 PM
so if there isnt anything else, i say we call this thing done and do it all again in a fortnight.
8:52
slack says no one is furiously typing so, see all y’all in two weeks. as ever, if there is something you want discussed, message me directly or just drop it here for us to pickup
Diego Molina 8:53 PM
thank you @adamgoucher!
Simon Stewart 8:54 PM
Thanks, @adamgoucher!
David Burns 9:24 PM
Argh… missed it again!!!
9:28
For CoC, I keep dropping the ball on this one. I have been busy with work but hopefully can do something in the next two weeks
Continuing the series of bi-weekly public project meetings, here is the timeline of the meeting held on April 23, 2020 (times are on CET).
Meetings are held on the #selenium-tlc
channel on Selenium Slack.
The next meeting will be on May 7, 2020, 4:30 PM CET.
Diego Molina 4:32 PM
Hi all, we are going to start the next project status meeting in a moment
for now, the agenda would be:
Simon Stewart 4:32 PM
Does someone want to announce it on the main #selenium channel too?
Diego Molina 4:33 PM
I can do that
Simon Stewart 4:33 PM
Thanks
Diego Molina 4:34 PM
before we start, does anyone want to add a topic?
4:36
maybe we can also discuss the Go bindings again
but I will take that silence as a “no more topics”
First topic, project stats: +/- issues, prs…
Simon Stewart 4:37 PM
@AutomatedTester probably knows those
Diego Molina 4:37 PM
Since a few weeks we are under 65 PRs and 400 issues, we made progress but not as significant as in the previous weeks
I am looking at a couple of OSS projects that build a dashboard so we have a better overview
Simon Stewart 4:38 PM
It’s the law of diminishing returns. We’re starting to hit actual issues and things that need thinking about
Diego Molina 4:41 PM
I experimented during the weekend with https://chaoss.github.io/grimoirelab/ and https://github.com/cncf/devstats, I liked the first one more, but we need to find a place where to deploy it for free Recently I bumped into https://github.com/google/triage-party, which could be also a good one to have an overview (edited)
4:42
all this in the spirit of having a clear project status for everyone
I can try to have something working for the next meeting, does anyone have more comments or should we move to the next topic?
Simon Stewart 4:42 PM
No comments from me
Diego Molina 4:43 PM
next topic: any staffing announcements, what did you mean by this @adamgoucher?
Simon Stewart 4:43 PM
@harsha509 has joined the team :slightly_smiling_face:
adamgoucher 4:43 PM
anyone get the commit bit, step away from a committee, etc.
Diego Molina 4:44 PM
well, @tourdedave mentioned he does not have the bandwidth to be in the TLC (which is my fault because I added him without asking, in the spirit of having someone from the IDE)
4:45
we could just leave it as it is or ask around if someone is interested?
Simon Stewart 4:45 PM
Having a strong owner for the IDE would be really helpful
Marcus Merrell 4:47 PM
I’m afraid unless he or Tomer change their mind, I’m not sure anyone exists who could fit the bill
we maintain really strong contacts with Dave.. that might have to be good enough for now
Diego Molina 4:48 PM
the TLC has no size limit, so things could continue as they are, right?
Simon Stewart 4:49 PM
They could
And it sounds a bit unfair to continue to lean on @tourdedave after he’s stepped away
Diego Molina 4:51 PM
what the IDE needs for now is support from the PLC, since Microsoft wants to help with having the extension on Edge (new), but I think @AutomatedTester asked to be introduced to them, not sure what the status is there
support as in, sort out legal stuff for creating an account on the MS store
Simon Stewart 4:52 PM
That won’t be hard. Someone needs to message the selenium@conservancy.org
Tomer Steinfeld 4:52 PM
I introduced @AutomatedTester I think the next step is to have someone from the SFC create an account
To do that we need PLC stamp
So that the SFC will do it
Simon Stewart 4:52 PM
@mmerrell want to run with that, or shall we ask @AutomatedTester to do it?
Titus Fortner 4:52 PM
What does that give the project though, if it isn’t the electron implementation?
Marcus Merrell 4:52 PM
I can run with it
Simon Stewart 4:52 PM
I’m happy with @AutomatedTester on point here :slightly_smiling_face:
Titus Fortner 4:52 PM
Not saying we should ever turn down help
Just curious
Marcus Merrell 4:53 PM
He might have better contacts than me
Simon Stewart 4:53 PM
@titusfortner support on Edge, and maybe someone from MS will step into the gap
Diego Molina 4:53 PM
to have the IDE working on the new Edge
Simon Stewart 4:53 PM
And also, and this is important, IDE working on Edge (as @diemol says)
Titus Fortner 4:55 PM
I thought all chromium apps worked already. I should actually use it :)
Diego Molina 4:55 PM
could we leave as an action item to have @mmerrell (since he is in the PLC) chat with @AutomatedTester in case David needs help with the PLC? and have a status for the next meeting?
Simon Stewart 4:56 PM
Sure
Diego Molina 4:57 PM
you ok with that @mmerrell?
while he answers, should we move slowly to the next topic?
Marcus Merrell 5:00 PM
yeah, I’m ok with that
Diego Molina 5:00 PM
next topic, whats been worked on (seems things are picking up again)
Simon Stewart 5:00 PM
I’ve some diffs lined up
5:01
When I get some bandwidth, landing those would be nice
After that, I’ll dig into the .Net stuff now that @jimevans has it working on macOS and see whether there’s some jiggery-pokery with select we can do so that bazel test //… will work the way we expect it to
Oh, I’ve also started wrapping OpenTelemetry with our own APIs so we do an update without too much chaos
0.2.0 -> 0.3.0 is messy
Diego Molina 5:04 PM
From my side:
Marcus Merrell 5:04 PM
ditto me for the “quiesce” feature, in terms of “working since SeConf” and “when I get some bandwidth”
Jim Evans 5:05 PM
@simonstewart let me know what you’d like to see here in terms of .NET.
Marcus Merrell 5:05 PM
the bulk of it is complete, still do to:
actually spin down the nodes
5:05
write unit tests
Simon Stewart 5:06 PM
I’ve still been pondering on how we make it possible to spin the grid up in an ad-hoc order
And I keep coming back to the fact that life would be easier if we had a backbone of a “message bus”, a “key/value store”, and a “service registry”
We definitely have the message bus already
And the session-map is perilously close to being a key/value store
Diego Molina 5:07 PM
conceptually I wanted to cover that in the support for retries issue, because we cannot expect the docker containers to start always in the same order
Simon Stewart 5:07 PM
Right
Regularly has support for a successful retry and an unsuccessful retry
But we can’t build everything on that :slightly_smiling_face:
Diego Molina 5:08 PM
I want to tackle that first, so at some point containers can be used in other envs
between https://jodah.net/failsafe/fallback/ and https://github.com/resilience4j/resilience4j I am liking more the first one (edited)
Simon Stewart 5:08 PM
You’re writing the code, and I like both of them :slightly_smiling_face:
5:09
Fallback is also used by an alternative netty-based http client
We may need to switch from AsynHttpClient because it doesn’t support http2 (or unix domain sockets)
5:10
I’ve been looking at io.projectreactor.netty:reactor-netty:0.9.6.RELEASE and I think @barancev may have some code
Or he may not :slightly_smiling_face:
Diego Molina 5:10 PM
I guess we can come back to that when some written code from my side actually works :slightly_smiling_face:
Simon Stewart 5:11 PM
Well, it means that looking at failsafe fallback is a better bet
Which leans into your preference
So it’s more a datapoint than anything else
Diego Molina 5:12 PM
sounds good
ok, should we move to the next topic, so we can hopefully finish on time
Simon Stewart 5:12 PM
SGTM
Diego Molina 5:12 PM
next topic is, what’s next & when do we plan the next release
Simon Stewart 5:12 PM
Next release? I’d like a banner feature in. WebSockets and CDP across the Grid would be it, for me
5:13
Or we can just ship what we have
Marcus Merrell 5:13 PM
that would be amazing
Simon Stewart 5:13 PM
It’s a SMOP
Simple Matter of Programming
Diego Molina 5:13 PM
we have 267 commits after the alpha 5 release, sounds like there could be something we can release?
Simon Stewart 5:13 PM
So I think the choice we have to make is “timed releases” or “feature releases”
Marcus Merrell 5:14 PM
I thought SMOP might be “Simple Matter of Pfantasy”
Simon Stewart 5:14 PM
git log selenium-4.0.0-alpha-5..HEAD --oneline java
5:15
HA! 098eb99991
5:15
We landed support for configs via TOML….
Diego Molina 5:16 PM
true, what if we try to have the retries thing, docs for toml, and maybe have a release before the next status meeting?
Simon Stewart 5:16 PM
Looks like lots of little fixes
DOCS?
:wink:
I can write an info section for configuration
Diego Molina 5:17 PM
that is what I was thinking
Simon Stewart 5:17 PM
kk
File an issue and assign it to me
(At some point, I need to do my day job)
Diego Molina 5:17 PM
before the beta some of us need to make those docs a bit nicer for Se4
5:18
I will do that then
Simon Stewart 5:18 PM
Thank you
Shall we mark some issues as “4.0a6”?
Diego Molina 5:19 PM
Maybe it is too much, not sure
Marcus Merrell 5:19 PM
my offer still stands to help with issue hygiene, I just need permissions
Simon Stewart 5:19 PM
Or, perhaps, let’s work on our features, and next meeting ship 4.0a6 regardless of where we are
@mmerrell I’ll fix that up for you now
And @harsha509 too
Sri Harsha 5:20 PM Js bindings is already at alpha7. We can try to implement relative locators(which is pending in JS bindings) and release in next meeting.
Simon Stewart 5:21 PM
That’d be great
Thank you
Diego Molina 5:21 PM
issue for TOML https://github.com/SeleniumHQ/selenium/issues/8232
Simon Stewart 5:22 PM
Thank you
Diego Molina 5:22 PM
ok, two topics left
first is, SeleniumConf status (for India and Chicago), and its website
Marcus Merrell 5:23 PM
I’ll see if I can get a website update from Bill McGee now that it’s a bit later on the west coast
Diego Molina 5:23 PM
so India will happen (:crossed_fingers: ) in September, and Chicago in November, does anyone know any news related to that?
Simon Stewart 5:24 PM
@mmerrell you should have an invitation from GH to join the SeleniumHQ org. Am slightly surprised you’re not a member already :slightly_smiling_face:
Marcus Merrell 5:26 PM
the conference status is currently:
so, at this point we believe we will be able to recover most/all funds from the Holiday Inn, based on Sauce’s experience with the Fairmont in Austin, and TestBash’s experience in Detroit
5:27
but we’re going to wait a few more weeks, a) because we can, and b) in case there’s some kind of earth-shattering news that comes out that changes the picture
Simon Stewart 5:27 PM
The UK has been told that social distancing will remain necessary until next year
Alexei Barantsev 5:28 PM
@simonstewart I don’t have any new code for http client yet, just an item on my todo list
Marcus Merrell 5:28 PM
as you might have seen, our leadership much more optimistic :face_palm:
Simon Stewart 5:28 PM
@barancev ok. There’s no rush
Diego Molina 5:29 PM
that’s a great update @mmerrell, thanks
something else I wanted to ask is, if we could have at some point the SeleniumConf website code and assets also under the SeleniumHQ GitHub org
Simon Stewart 5:29 PM
Totes up for that
5:30 I’ve another meeting to go to
Marcus Merrell 5:30 PM
me too. that’s where things get sensitive
Simon Stewart 5:30 PM
Toodle pip
Marcus Merrell 5:30 PM
but I think we need to head in that direction
Diego Molina 5:30 PM
and as part of this, add the general conference guidelines to the governance doc
Marcus Merrell 5:30 PM
yep, that’s on my plate
Diego Molina 5:30 PM
that’s fine, we can stop here as we have no more time
5:31
but we can keep the topic in our head for informal discussions
Simon Stewart 5:31 PM
You can carry on without me. I’m fine with that :slightly_smiling_face:
Diego Molina 5:31 PM
and have a status of it in the next meeting
5:32
to respect people’s time, we will end the meeting here, I will upload the minutes to selenium.dev, and prepare an agenda for the next one
5:32
thank you everyone!
As an initiative to bring more transparency to the Selenium project, we are now holding bi-weekly public project
meetings. These are written meetings which are held on the #selenium-tlc
channel on Selenium Slack.
Here is the timeline of the meeting held on April 9, 2020 (times are on CET).
The next meeting will be on April 23, 2020, 4:30 PM CET.
Simon Stewart 4:31 PM @adamgoucher there needs to be a calendar invite for these things
adamgoucher 4:32 PM well, originally the idea was that people could manage their own calendars but if you send me which email you want it attached to i can add you to the one ive been putting people on who wanted an invite
4:35 anyhow; here’s the rough approximation of an agenda. we’ll see how it goes;
4:38 anything governance-y that needs to be discussed in public (not limited to, but including public announcement of people getting the commit bit, etc.)
Diego Molina 4:38 PM if there is time, let’s add the recent topic of adding go bindings
adamgoucher 4:38 PM has there been an sfc call recently? (i cant remember when they are)
Diego Molina 4:40 PM governance related, I’d say: we need to define where we put these meetings minutes, how we announce them widely (do we need?), and that we still need a code of conduct
adamgoucher 4:41 PM ok. @diemol pester my monday morning if i haven’t figured out how to get them onto the blog by then
Diego Molina 4:41 PM So, meetings minutes… we can put them in the same format as a blog entry, and we can tag/label them so they are publicly accessible I can do that, I would just need the contents of the previous meetings, and also add small instructions on how to add new ones
adamgoucher 4:43 PM i think we just start with this one. i didnt take the most excellent notes the last couple and they might have expired out the channel (havent scrolled up to check)
Diego Molina 4:43 PM ok, so I will start doing that with this onee
adamgoucher 4:44 PM who is the point person for the code of conduct
Diego Molina 4:44 PM @AutomatedTester said something about being working on it? 4:44 but we currently have a draft, why don’t we use that draft and iterate on it?
adamgoucher 4:45 PM makes sense. as we did with the other doc
4:46 ok. next thing on the list is status of prs. which @AutomatedTester has been culling like a mad man over the last week and we’re down the 62
4:47 followed closely by status of issues and there is now 402 which i think he is also attacking (but i dont have a number from 2 weeks ago)
Diego Molina 4:48 PM perhaps we should set up a project health status dashboard I saw a couple of OSS projects that could do that
adamgoucher 4:49 PM could be interesting. of course we could also then get into wild semantic discussions around ‘what’ healthy is. :smile:
4:50 next; status of se project related events (india, chicago are the big ones)
4:51 i saw that seconf india has been moved to september. how is chicago looking?
Diego Molina 4:51 PM I think no one is around who could reply that question
David Burns 4:52 PM I also think it’s too early to comment. Chicago is in lockdown at the moment for the foreseeable
4:52 we also need to be see how many venues are still around when we come out of our homes
Isaul Vargas 4:53 PM As for big cities in the US, only by End of May can we know if restrictions will be lifted due to testing and lowering the curve.
adamgoucher 4:53 PM (it has more of a recurring agenda item more than me seeing someone who can answer)
4:54 and restrictions will be lifted in june and clamped back down in july. as is the way in a pandemic. (and really, will be until we get a vaccine)
4:55 next item; next release status and/or timeline. @simonstewart?
Simon Stewart 4:55 PM India has been moved to later in the year
4:56 We’re running the 4.0 release in the open: https://github.com/SeleniumHQ/selenium/projects/2
4:56 The config stuff won’t be too horrible. I’m quite liking the fact that TOML opens up some options
adamgoucher 4:56 PM yup. so is your plan still ‘push the button on stage to do the release and retire for your daily beverage’ or are we aiming for a same-ish part of the calender
Simon Stewart 4:56 PM When we ship, I stand down
4:57 I’d still like to get the betas out soon
4:57 But there are some big pieces missing before we can get to that point
4:58 The big one being the CDP stuff across Grid, which I’ve many of the moving parts for in various branches on my machine
Diego Molina 4:58 PM when I look at the things on the “to do” column, maybe 80% is Grid, right?
5:00 if so, it is something that calms me down because at least (from my side), I am having slowly more time to work on the code
5:00 but there are a couple of things on that list which concern me: IDE to the monorepo (and build it with bazel) + implement CDP and relative locators in JS
David Burns 5:01 PM I am doing the IDE to mono repo now
5:01 relative locators in JS should be easy, I can do it or talk @harsha509 through it
Diego Molina 5:02 PM but in the IDE, what is our approach in terms of browser extension vs. electron
5:02 right now we could only do the browser extension, right?
David Burns 5:02 PM that is separate from the mono repo work
5:03 these are questions for @tourdedave and @corevo
Simon Stewart 5:03 PM Right now, there’s just the browser extension, but @tourdedave and @corevo did start work on the electron port
5:03 I’m not sure what kind of progress they’re making, if any
Diego Molina 5:04 PM ok, so it seems we will only focus on the browser extension for now
adamgoucher 5:07 PM ok, so to summarize; all the known to-dos are in the github project india has been shifted, but dont want to just move the target to september aiming for betas to start soon, grid cdp is really the last big hurdle until those can start
Diego Molina 5:08 PM and the JS stuff, right?
5:08 (CDP + relative locators)
adamgoucher 5:09 PM i think we can skip the next thing which is ‘how are people progressing on the stuff they signed up for’ with a ‘see the github project’
5:11
because the next thing on the list i prepared was - anything that needs to get sussed out in public
which, for today, means ‘what to do about javascript’. not sure that anything got resolved the other day but i think the core of it is ‘webdriver.js is the official binding but not under the auspices of the project’ or something?
Simon Stewart 5:11 PM To reiterate feedback from other people, and my own reflections:
5:12 There is a general feeling that the selenium project should own the core of its own bindings We’ve gone from having basically no-one interested in JS to having Sri on board (@harsha509) We’ve not nailed down the overall strategy yet
5:14 Which kind of suggests not using webdriver.io’s webdriver module, but continuing to work with our own stuff
5:14 Unless that module moves under the aegis of the project
Diego Molina 5:15 PM oh, actually I was talking to @christian-bromann about it, and he manifested again his interest to help move the JS bindings to use the webdriver package, and leave things ready for someone who wants to maintain the bindings
Simon Stewart 5:15 PM And if the code for the webdriver package was in our repo, I think that’s probably what we’d do
Diego Molina 5:16 PM I am not a 100% sure that he is ok with moving the code from that package to our repo but in the worst case, would a copy/fork of the code work?
Simon Stewart 5:17 PM That seems like a bad idea
Christian Bromann 5:17 PM What is the problem of not having the webdriver binding in the Selenium repo?
Simon Stewart 5:18 PM The feedback I’ve had from several people has been that they’re deeply uncomfortable with it, and won’t approve of it
5:18 It’s not just a technical thing
5:18 There are the social aspects to consider too
Christian Bromann 5:19 PM I understand.
Diego Molina 5:20 PM well, the idea of the committees is to reach consensus in these cases, and it looks like we would never reach it for this situation
Christian Bromann 5:20 PM Well the idea of generating raw bindings based of some json files is pretty easy to reimplement and I am happy to support how it can be done.
5:22 copying over the code form WebdriverIO to Selenium is rather difficult as it depends on some other wdio utilities (logging and utility functions)
Simon Stewart 5:22 PM I do wonder how far adrift the JS bindings are
5:23 The obvious missing 4.0 features are relative locators and the CDP integration
5:23 The CDP integration isn’t nailed down properly anywhere. We’ve got access to the raw protocol, but we’ve yet to build the abstractions people would actually write against
Christian Bromann 5:23 PM Given the situation I am would be also happy to invite the Selenium JS contributor to the WebdriverIO org to ensure code access and ability to merge/review code changes.
Simon Stewart 5:24 PM Thank you
Diego Molina 5:25 PM well, then it seems JS bindings stay as they are hopefully we all find a way to make them fit for the 4.0 release
5:25 should we talk about the go bindings?
adamgoucher 5:26 PM thats the only other thing on my list
Simon Stewart 5:26 PM We can talk about Go bindings
5:27 Miki offered to donate https://github.com/tebeka/selenium to the project a while ago
5:27 I got busy and had health issues, so dropped things on the floor
5:27 Should we pick that back up again?
adamgoucher 5:28 PM is he also intending to maintain it (dunno the status of them) or is it a ‘i did a thing and dont need it anymore so someone can pick it up if they want’
Simon Stewart 5:28 PM I dunno
5:28 That would be part of the conversation
David Burns 5:29 PM if it’s the latter then I am not sure we would want them. It’s amazingly nice but the maintenance burden, potentially, doesnt feel worth it
Simon Stewart 5:30 PM Indeed
5:30 But it would be nice to have some “official” Go bindings.
adamgoucher 5:30 PM i know nothing about go, but i feel like the bar for any binding to be included in the main project; is it maintained? is it idomatically correct for the language? is there not a competing, more obvious one to incorporate?
Simon Stewart 5:30 PM Turns out that people like them
5:30 s/them/the language/
Diego Molina 5:30 PM seems it is worthy to give the conversation a go
5:30 who would like to drive that conversation with Miki?
Simon Stewart 5:31 PM It’s pretty dormant right now, but is that due to being complete? My understanding is “yes” Nothing that I’m aware of
5:31 puts finger on nose
adamgoucher 5:31 PM sounds like ‘you are a go’ for the conversation about go. as it were
Simon Stewart 5:31 PM Not me
5:31 Yeah, I think it’s a conversation that’s well worth having
Diego Molina 5:32 PM I can see from a quick look that the go bindings have vendor stuff in it, for example it has the ability to use Sauce Labs out of the box
5:33 even if I work for Sauce, we need to see all those things in case we want to merge them
Simon Stewart 5:34 PM Aye
Diego Molina 5:36 PM I know how the Grid works (in general), but I still have black spots in my head when talking about bindings we need someone who knows how bindings should work and do a check on the go bindings
adamgoucher 5:37 PM sounds like ‘we think having the go bindings in the main project is cool, but currently the people in the channel right now dont have enough interest (or knowledge) to drive the conversation’
5:38 likely also have to talk to sfc about rights transfer and such. though the existing licensing could cover it
Diego Molina 5:39 PM maybe we bring the topic back in 2 weeks and see how people feel?
Simon Stewart 5:40 PM SGTM
adamgoucher 5:41 PM ok. i didnt have anything else? did anyone else?
Simon Stewart 5:42 PM I’ve got other meetings to attend, so nowt from me
adamgoucher 5:43 PM taking silence from the rest as a no. thanks everyone!
Diego Molina 5:43 PM Thank you all!
Check out all the SeleniumConf London 2019 videos and photos!
You can find all the videos here, and all the pictures here.
If you cannot wait to get started, feel free to watch below Simon’s “State of the Union” keynote!
In August of 2017 Simon shared the bleak, hard news that as of Firefox 55 Selenium IDE would no longer work. Selenium IDE (or as we’ll refer to it from here on out – the Legacy IDE) was, and is, dead.
Since then quite a lot has happened with the IDE. We have a new version of it which we are referring to as… Selenium IDE!
It is currently in “alpha” and available for use in both Chrome and Firefox.
In his post Simon also mentioned “the fine people at Applitools“. This includes Tomer Steinfeld, Dave Haeffner, and Doron Zavalevsky. Together, along with contributions from the rest of the Selenium community and the SideeX project, we have been able to get the new Selenium IDE out into the wild. We are also working to close the gap on feature parity with its predecessor along with adding some much needed enhancements to the tool (more on that in future posts).
We’d love for you to give the new IDE a try and let us know what you think. Visit either the Chrome Web Store or Firefox Add-ons to install it. For info on how to use the tool, you can check out the getting started documentation on Selenium HQ.
If you have any questions you can find us on the Selenium Slack/IRC chat channel. Think you found a bug? File an issue. Want to contribute? Take a look at the project on GitHub.
Happy Testing!
The bad news: from Firefox 55 onwards, Selenium IDE will no longer work.
The reasons for this are complex, but boil down to two main causes:
Selenium is one of the most widely used pieces of testing software there is. Despite this, the team of people regularly contributing is small: since the start of the year, there are only 11 people who have made more than 10 commits, with two people accounting for more than half of those. Since 2016, only one person has been maintaining the IDE.
Selenium is an Open Source project. None of the core contributors — not the IDE maintainer, not the language binding owners — are paid to work on work on it. They do it because they love working on the code, and they typically do it in their “copious free time”. The IDE maintainer has had almost none of that to spare. We should all be thanking that committer for his time and effort. Thank you, Samit!
So what can we do to move forward? The first thing is that there are now a wealth of tools that are stepping up to fill the gap. You should go and have a look at them. The second thing is that there is an effort to rebuild IDE using modern APIs, to be usable across more than just Firefox. The fine people at Applitools are helping with this effort.
The third thing? That’s you. You could help us.
If you believe that a friendly UI for quickly recording and playing back tests is a useful Open Source tool, then please come and join us! The main technical discussions are happening on the #selenium IRC channel. If you’d prefer Slack, you can join us on that too. Or there’s the ever useful selenium-developers mailing list. Come onboard. We’d love your help, and IDE is a wonderful thing to contribute to!
Jetbrains have a programme for Open Source projects which allows them to receive IntelliJ IDEA licenses. As part of that programme, which the Selenium project has participated in for many years, they’ve asked us to provide a fair and balanced review of IntelliJ. I’ll attempt to do that, and I’ll try and state my biases up-front so you’re aware of them.
I’ve been using Jetbrain’s IntelliJ to hack on the Selenium code since I started working on it slightly over ten years ago. It’s still my favourite IDE for my Java work, and it’s plenty of fun to use. For some time, I’ve been using the (free) Community Edition, which is ample for many coding needs.
Most of my work is in Java, and that’s where I know IDEA best. I dabble in Ruby and Python, and I’ve written a reasonably large amount of Javascript, all in IDEA.
The Pros:
In common with other good IDEs, IDEA has the ability to work seamlessly with many different languages. If you’re a polyglot programmer, being able to stay in the same tool for much of your work makes life a lot easier. On the Selenium project, we use Java, C#, Ruby, Python, and Javascript extensively. I don’t do any C#, and I mainly focus on Java, but the support for JS, Ruby, and Python is lovely and seems to work well. The built in type detection and code navigation features are impressive (particularly for untyped languages such as JS)
Of course, the feature that made IDEA so awesome in the first place is the range of refactoring options it offers. These are great, and always have been. One nice feature I’ve noticed as we move to a Java 8 future (finally!) is that it offers suggestions to help migrate to new features where they make sense (and, I’ll be honest, sometimes when they don’t). It’s made making use of lambdas a lot easier.
For a while, IDEA was becoming slower and more bloated, but I’m pleased to see that, partly thanks to the work of developers from Facebook, the latest releases feel snappier and handle larger projects more efficiently. One thing I appreciate is how open Jetbrains were to receiving patches to their core product: it displays a level of respect for external contributors that I feel is important (of course, I would think that: I work on OSS for fun!)
There’s a nice wide range of plugins available for IDEA. I’ve hooked up the Buck plugin and made use of it. Without an extensions API, this plugin wouldn’t have been possible, but having them there is incredibly useful and makes the IDE even more capable.
Finally for the plus points of the IDE, I love that the IDE tracks new versions of Java relatively closely — it’s fun to see what new language features we’ll be able to use in the future!
The Cons:
Although it’s a fine product, there are some niggles to be had.
Most annoyingly, the built in code analysis doesn’t always warn that some Java classes won’t compile. The most recent example was where IDEA didn’t flag that some lambdas couldn’t be used since the choice of method to use was ambiguous. This may be because the Java language continues its slothful way forward, and the compiler improves with each release — certainly these same files compiled just fine with older Java releases.
When an error does happen, I’ve yet to find the magic setting to allow IDEA to keep going as far as possible. One of the features I like about Eclipse is that it’ll compile as much as it can, even if there are invalid source files. When doing TDD, this allows you to move just a little bit faster as unit tests can run and pass so long as they don’t touch faulty code. I dearly wish this same capability was present in IDEA!
On the Selenium project, we use Buck for our builds. The Buck plugin doesn’t (yet!) allow me to build and run tests within the IDE, yet Buck performs some steps that can’t be repeated by the IDE that are required for a successful build. IDEA offers the ability to run an Ant step before a build is run, and it would be extremely useful if this was generalised to “any shell command”. Most of the time, it’s fine, but it’s irksome to forget to run things!
On the whole, I love IntelliJ an awful lot. It’s a fast and capable IDE, and the company behind it supports OSS. What’s not to love?
We are very pleased to announce the release of Selenium 3.0. If you’ve been waiting for a stable release since 2.53.1, now’s your chance to update. And if you do, here is what you’ll find:
As we’ve said before, for users of the WebDriver APIs this is a drop-in replacement. You’ll find that modern browsers, such as Chrome and Edge will continue to work just as before, and we’ve taken the opportunity to fix some bugs and improve stability. Selenium Grid users may require updates to their configuration as the json config file format has been updated, as have some of command line parameter options, but the upgrade should also be smooth.
The major change in Selenium 3.0 is we’re removing the original Selenium Core implementation and replacing it with one backed by WebDriver. This will affect all users of the Selenium RC APIs. For more information, please see the previous post.
A lot has changed in the 5 years between versions 2 and 3. When we shipped Selenium 2, the Selenium project was responsible for providing the driver for each browser. Now, we are happy to say that all the major browser vendors ship their own implementations (Apple, Google, Microsoft, and Mozilla). Because the browser vendors know their browsers better than anyone, their WebDriver implementations can be tightly coupled to the browser, leading to a better testing experience for you.
The other notable change has been that there is now a W3C specification for browser automation, based on the Open Source WebDriver. This has yet to reach “recommendation” status, but the people working on it (including members of the Selenium project!) are now focusing on finishing the text and writing the implementations.
Mozilla has been a front-runner in implementing the W3C WebDriver protocol. On the plus side, this has exposed problems with the spec as it has evolved, but it also means that Firefox support is hard to track as their engineering efforts have been forward looking, rather than on supporting the current wire protocol used by Selenium WebDriver. For now, the best advice we can offer is for you to try the latest release of geckodriver and Selenium together.
These are exciting times for browser automation! Selenium 3.0 is a major release and we’re looking forward to improving things further, as well as tracking the ongoing work of the W3C spec. Our goal is to keep the changes your tests need to deal with to an absolute minimum, to continue preserving the hard work that’s gone into writing your existing tests.
As a personal note, I’d like to say thank you to each of the many people that have worked so hard to make Selenium 3 possible. That’s not just the developers and contributors to the Open Source project (past and present), but also the engineers from Google, Microsoft, Mozilla, and Apple, and everyone involved with the W3C spec. I’d also like to say thank you to everyone who’s taken the time to report bugs, our users and our community. The project is great fun to work on and you’re the reason for that. A final thank you is due to the Software Freedom Conservancy, who have provided invaluable help with the logistics of running a large OSS project.
Happy hacking, everyone! May your tests run fast and true!
Selenium 3 is coming! As I write this, we think that “beta 4” will be the last beta before the official 3.0 release. I’m here to tell you about what’s changed, and what impact this will have on your testing.
When we released Selenium 2.0 in 2011, we introduced the new WebDriver APIs, and encouraged everyone to start moving to them. If you’re using the WebDriver APIs, then Selenium 3.0 is a simple drop-in upgrade. We’ve not changed any of the public WebDriver APIs, and the code is essentially the same as the last 2.x release. If you’re using Selenium Grid, the same applies: in most cases, you can just drop in the new JAR (or update your maven dependency to 3.0.0), and you’re done.
If the update to Selenium 3 is such a non-event, why did we call this Selenium 3.0? To answer this question, I first need to provide some history, and tell you a little about how Selenium works under the hood. The very first version of Selenium was “just” a very complicated Javascript framework, running in the browser and interpreting the table-based tests you may be familiar with if you use Selenium IDE. We call this “Selenium Core”. This Javascript framework formed the basis of the original implementation of Selenium RC (the oldest set of Selenium APIs, where all the method and functions were on the “Selenium” interface, and which have been deprecated for some time now). Over time, the needs of modern web testing have grown ever more complicated and sophisticated, and Selenium Core is now less capable of meeting these needs than it was before.
With Selenium 3.0, we are deleting the original Selenium Core implementation. If you use the old RC interfaces, we provide an alternative implementation that’s backed by WebDriver. This is the same “webdriver-backed selenium” that has been available as part of Selenium 2 since its release. Because the underlying technology has changed from Selenium Core to WebDriver, you may find some places where your existing tests using RC run into issues. Our experience with migrating suites is that it’s normally a systemic issue that can be fixed with a minimal engineering effort (that is, the problem is normally isolated to a few places, and these can be rewritten to avoid problems)
We’re also removing the original Selenium RC APIs from the main downloads. If you’re a Java user, and need to use them to support existing tests, then you’ll need a dependency to “org.seleniumhq.selenium:selenium-leg-rc:3.0.0” (or later!). It’s strongly recommended that you do not do this unless you absolutely need to.
If you’re someone who runs tests exported from IDE in the table format, there is now a new test runner that the project has made available for you to use that can be downloaded from the project’s website. It takes the same arguments as the old runner, and we’ve done our best to ensure the output of tests remains the same too.
At the same time as the Selenium project is shipping Selenium 3.0, Mozilla are changing the internals of Firefox in a way that makes it more stable and secure, but which also makes the community provided Firefox Driver no longer work. As such, if you use Firefox for your testing, you’ll need to use the geckodriver, which is an executable similar to the chromedriver and the Microsoft WebDriver for Edge. You’ll need to start using geckodriver even if you’re using Selenium 2 — the change is in the browser, not Selenium. Please be aware that geckodriver is alpha software, based on the evolving W3C WebDriver standard: everyone’s working flat out to give you the best testing experience they can, but there are undoubtedly some bumps in the road when it comes to testing with Firefox.
This release marks the culmination of a lot of hard work by the Selenium committers and community. I’d like to thank everyone who has been part of this process, and the Selenium users around the world who have done so much to make the project as successful as it is.
At SeleniumConf in 2013, we announced that a new major version of Selenium would be released “by Christmas”. Fortunately, we never said which Christmas, as it has taken us a while to make all the changes we wanted to make! We’re excited to announce the release of the first beta — Selenium 3.0.0-beta1.
We’d love you to try it out on your projects, and provide us with feedback on where the rough edges are before we ship the 3.0 itself! Please remember that this is a beta release, so your feedback is incredibly helpful and valuable in order to help us smooth any rough edges.
For the last six years we’ve been advising users to switch to the newer WebDriver APIs and to stop using the original RC APIs. With Selenium 3.0, the original implementation of RC has been removed, replaced by one that sits on top of WebDriver. For many users, this change will go completely unnoticed, as they’re no longer using the RC APIs. For those of you who still are, we’ve done our best to make the change as smooth as possible, but we welcome high quality bug reports to help us fix any problems that occur. Maven users will need to add a dependency on the new “leg-rc” package to access the old RC APIs.
There are some other changes that you might need to be aware of:
We’ll be posting more information about Selenium 3.0 to this blog soon, but until then if you’re interested in learning more then a recent webinar by Simon is a great place to start.
We’re excited to announce that we’ve finally determined where and when Selenium Conf will be happening this Fall.
Our initial goal was to bring the event to a new country, but for a number of reasons that proved more challenging than we’d hoped. But in 2012 we had the 2nd annual Selenium Conf in London, and we’re pleased to be bringing it back there this year!
The conference will be held at The Mermaid in downtown London on November 14-16:
Go here to sign up for the email list for conference updates (e.g., when tickets go on sale) as well as submit a talk. Call for speakers are open from now until July 29th.
Selenium Conf India is happening this June 24-26 in Bangalore, India.
Tickets, call for speakers, and sponsorship slots are now available!
In our last update we mentioned there will be 2 Selenium Confs in 2016 — one in India, another somewhere else (TBD).
Well, we are pleased to announce the official dates and location for Selenium Conf India!
When: June 24th & 25th, 2016
Where: Bangalore, India (at The Chancery Pavilion Hotel)
Mark you calendars! We’ll have more details as they become available (e.g., call for speakers, ticket sales, etc.). To get the latest updates, be sure to sign up for the Selenium Conf mailing list.
Interested in learning what’s in store for Se Conf 2016? Then be sure to read this write-up from the Conference Organizers.
Also, if you want to receive email notifications about the conference (e.g., when and where it will be, call for speakers, ticket sales, etc.) then go here and complete the sign-up form.
Selenium 2015 is just around the corner (September 8-10). Since our last post we have:
You can see keynote & workshop info here, and the selected talks here.
If you still need a ticket, the last block of tickets are on sale NOW.
If you want to attend the conference then register ASAP. Tickets will go quick and once they’re gone, they’re gone. To register go here and purchase either a Last Call or Last Call + Workshop ticket.
The Selenium Conf 2015 website is live!
You can now:
– purchase tickets (while supplies last)
– find out venue information
– submit a talk
– learn more about our talk selection process (tl;dr it is a blind review process to encourage diversity)
What are you waiting for? Go to the conference website already!
Selenium Conf is coming to Portland, Oregon this year!
It will be happening on September 8, 9, and 10. Mark your calendars.
Stay tuned for details!
Every year, Jetbrains are kind enough to donate an OSS license for IntelliJ to the Selenium project. As part of that process, they’ve asked that we review the product and (kudos to them!) have been clear that they hope we’re open and honest. So, I’ll be open and honest.
When I tell people that I’m a professional Java developer, people in some circles make sympathetic noises and (sometimes) jokingly refer to how painful my coding life must be. After all, there are several far trendier and hipper languages, from Ruby, various flavours of Javascript, Python, Haskell, and even other languages running on the JVM such as Scala and Clojure. I tend to agree that Java is a relatively unexciting language as it’s generally practiced — Java 8 contains a wealth of goodies that lots of people won’t be using for years since they’ve still got to support Java 6(!) apps. Where I disagree with the detractors is that using Java is something to feel sorry for a developer for: Java on its own isn’t much fun, Java and IntelliJ is one of my favourite programming experiences.
I’ve been using Java since the (very) late 90s, and have been using IntelliJ off-and-on since 2003 or so. In the intervening just-over-a-decade, what started as a tool that crossed the Rubicon of “being able to do refactoring” has matured. It has literally changed the way I write code: I now use the “Introduce Variable” refactoring to avoid needing to do initial assignments of values to variables as a matter of course. Indeed, with IntelliJ, I frequently stop thinking about the programming language and start thinking about the structure of the solution. Its refactorings make exploring large scale changes easy and entirely reliable, and once the restructurings are complete, I can jump to symbols with ease.
Code exploration is aided by the simple and quick ways IntelliJ can find usages, and it’s simple to find unused code as method declarations get highlighted in a different shade to used ones. The integrated debugger is sufficiently capable that, coupled with unit tests, it’s normally pretty easy to figure out why some odd behaviour is happening. And, speaking of unit tests, the UI is clear and (I find) intuitive and easy to use.
And those users of fancy-pants languages such as Clojure, Ruby, Python and Javascript (and PHP) can get plugins that extend IntelliJ’s capabilities and insight into those languages. Although it’s been a long time since I’ve had to deal with Spring and JEE, when I do IJ has my back, grokking the config files. The maven and gradle integration appears to work too, though Selenium uses CrazyFun and is migrating to Buck, so I’ve seldom any need to
It’s not all wonder and joy. On large, multi-module codebases, IntelliJ seems to spend too long building caches. Activity Monitor on the Mac suggests it’s doing this in a single threaded manner, which is wasteful on a multicored machine. Switching away from IJ, doing something on the command line involving source control and then switching back is a sure-fire way to make it rebuild the caches, making it unresponsive. Extending IntelliJ by writing plugins is a black art — the documentation is scattered and appears out of date, making getting started on writing one hard.
Overall, though, I love IntelliJ. On the Selenium project, it’s the IDE of choice, and I’ve been incredibly productive in it. Thank you, Jetbrains, for a wonderful tool.
01:35 – 9:45 W3C Update
Notes from most recent W3C Meeting
Highlights:
– changes to the get_attribute method call
– screenshots (changing to viewport only, eventually will support whole page)
– The WebDriver W3C working group has a GitHub repo now
– WebDriver will move from a “REST-ish” to a more “RESTful” interface
11:23 – 16:00 Selenium 3 Status Update
16:05 – 17:10 Marionette (FirefoxdDiver rewrite) testing help
Marionette Roadmap
17:20 – 19:27 ChemistryKit rewrite
Announcement blog post
17:28 – 20:24 Visual Testing Part 1
Getting Started with Visual Testing
Applitools (visual testing cloud solution built on top of WebDriver)
20:25 – 23:47 Selenium Guidebook in Java!
The Selenium Guidebook
23:52 – 29:51 Visual Testing Part 2
Web Consistency Testing
Why MogoTest won’t be open sourcing it’s code after shutting down
Michael Tamm’s GTAC talk on Fighting Layout Bugs
Getting Started with Visual Testing
0:00 – 01:10 Intro
1:11 – 13:00 WebDriver W3C Spec & Selenium 3 Update
13:01 – 24:10 Selenium Conf 2014 Update
24:11 – 39:00 Discussion about 5 Hidden Costs Of Selenium Whitepaper from Telerik
It makes me enormously happy and proud to announce that the Selenium Conference 2014 will be held in Bangalore on the 4-6 September. I’m looking forward to seeing you there!
One of the plans we’ve had from the very beginning for SeConf was that it was going to be a conference for the community of people who make Selenium such a fun project to work on. One way to do this was to host the conference where the largest groups of people using Selenium are found. We kicked off the first conference in San Francisco mainly because of the large number of Selenium users there (and, I’ll be honest, because that’s where the organising team had the most experience and contacts!)
In Europe, that large pool was London, so we held the second conference there. We had originally planned for the third conference to be in New York, but that proved to be a little too expensive, so we moved it North a little to Boston. Essentially, the pattern is that we alternate between the US one year and The Rest of the World the other.
That brings us to the planning for Selenium Conference this year. We had a look at the data available to us, and noticed that there were two areas of the world that it would be great to take the conference to. Selenium Camp, hosted in Kiev each year, does a great job of catering to one of these groups, so that leaves the second.
It’s India’s turn. 🙂
Thank you to everyone who’s already poured so much heart and spirit into this conference. We’ll be putting up a call for papers and more details soon, so please stay tuned!
Here’s a recap from the latest Selenium Hangout panel discussion. To submit questions for future hangouts, you can message us on Twitter (@seleniumhangout) or e-mail us (questions@seleniumhangout.com).
Panel
David Burns (@AutomatedTester)
Kevin Menard (@nirvdrum)
Dave Haeffner (@TourDeDave)
Timeline
1:30-16:51: How to handle screenshots across different drivers
tl;dr driver specific issues due to a lacking standard and missing API
17:30-22:40 : Internet Explorer (IE) 9 pitfalls and how to avoid them
tl;dr use 32-bit IE (if you’re not) and report issues to Selenium Issues
22:50-28:30 How do you do image and video comparison testing?
tl;dr straight image comparison is a flawed strategy, but there’s a better way — also, Selenium’s not the best tool for the job
Resources mentioned:
28:58-38:15 How do you get started with Selenium?
tl;dr pick a language you feel comfortable with, choose an editor that makes you productive, and dig into the available resources
Recommended resources:
38:23-42:50 Selenium 3 Update
tl;dr still a work in progress, steadily moving forward, a big update will likely be required
43:15-44:00 Conference Update
tl;dr nothing finalized, hoping to do it internationally, but US is a fallback; still working on options (will know soon)
44:10-45:20 Mobile Changes to the Selenium project
tl;dr Android and iPhone Selenium drivers deprecated in favor of other compatible libraries
Compatible libraries:
45:20-47:30 New Mobile Selenium Drivers
tl;dr RIM (BlackBerry Smartphones) and Microsoft (Windows phones)
TL;DR: We’re retiring Selenium’s own AndroidDriver and iPhoneDriver in favour of any of Selendroid, iosdriver and Appium. If you’re using one of Selenium’s own mobile drivers, please evaluate one of these alternatives.
The longer version:
In 2007, Steve Jobs announced the iPhone and changed the mobile Web from a curiosity to something the mainstream wanted and used. Current trends suggest that mobile Web usage will surpass desktop usage in the not too distant future. Which is a long way of saying the mobile Web is going to be a big part of the future of your sites and that it’d be an extremely wise idea to test them on mobile devices.
The Selenium project responded to the rise of the mobile web by working to produce WebDriver implementations for both iOS and Android. The first lines of the iPhoneDriver (which also worked on the iPad) were added to the project early in 2009. The AndroidDriver was added in June 2010, and was primarily developed by engineers at Google. To this day you can download the official Android SDK and find “Google WebDriver” as one of the optional extras you can download.
After the initial work on the mobile drivers, something interesting happened. Experimental extensions and modifications to the drivers were made outside of the selenium project. The first one of these that I was involved with was “nativedriver“. This took the novel approach of allowing users to interact with the native UI of the phone, be it Android or iOS, using the familiar WebDriver APIs. The first time I saw it, I thought it was madness, but the engineers working on it soon convinced me that it made sense. And guess what? They were right.
Sadly, after proving the idea was viable and workable, the NativeDriver project ran out of steam, but it set the scene for three projects that have taken the idea and run with it to create remarkably capable pieces of mobile testing software: Selendroid, iosdriver and Appium. All three of these allow a tester familiar with the WebDriver APIs to test mobile apps on iOS and Android. Not only native ones, but also hybrid or pure web-based ones too. They’ve recently been joined by the Windows Phone WebDriver, which allows testing of mobile web apps on WinPhone 8.
All of these projects have something in common: they’re far more active, more capable and have pushed further than the equivalent code in the main selenium project. In fact, some of the members of the selenium team that contributed to both AndroidDriver and iPhoneDriver are now also working on those other projects. There’s work being done to maintain interoperability between the different drivers, allowing users to chose which framework is most appropriate for their needs without fear of their tests needing major rework.
This means that keeping the existing Android and iPhone drivers within the Selenium project isn’t helping our users. The alternatives are better, and keeping “official” drivers within the project muddies the water. Worse, the selenium developers are slow at making fixes to those drivers, which is incredibly frustrating for everyone involved. Because of this, the Selenium project has deleted the code for those drivers from its repository and we recommend you evaluate and use one of the alternatives.
Of course, the code will still live in our repo’s history, so if you’d like to build them yourself, then it’s still possible. The last version with the iPhoneDriver is ef9d578, and the last one with the Android source is 00a3c7d. We’ve uploaded a version of the AndroidDriver built from that revision to the downloads page to save you having to do so yourself.
These changes do not mean that we don’t support mobile as a project. It just means that we support the best implementations of mobile WebDriver, and those aren’t written as part of the Selenium project.
Here is a recap of our most recent Selenium Hangout where we answered a grab bag of questions ranging from how to use Selenium within your existing workflow down to nitty-gritty details around performance and deprecated functions.
Be sure to tune into our Twitter feed to find out details about our next Hangout.
And if your question didn’t get answered, we encourage you to hop on IRC and ask it there. Not sure what that means or how to do it? Then read this.
Panel
David Burns (@AutomatedTester)
Dave Haeffner (@TourDeDave)
Jim Evans (@jimevansmusic)
Kevin Menard (@nirvdrum)
Timeline
00:00 – 05:50
Preamble and Introductions
05:51 – 18:09
Question 1 – For a team getting started with Selenium what are some typical workflows for how product code is built, and Selenium tests built, as well as for when product code is modified and Selenium test modified?
18:10 – 34:15
Question 2 – Recommendations for testing responsive design?
34:15 – 37:44
Question 3 – Was VerifyText removed?
37:45 – 46:20
Question 4 – Why is IE9 slow and hard to use and recommendations for alleviate this?
46:21 – 50:11
Question 5 – ChromeDriver2 seems less robust than it’s predecessor, thoughts on this?
50:12 – 53:39
Question 6 – The Selenium documentation is out of date, how can I contribute a fix for this?
53:40 – 54:31
How to help out with the Selenium Conference?
Links mentioned
This is a recap from the most recent Selenium Hangout (a.k.a. The World’s Best Selenium Meetup). For info on future meetups, follow them on Twitter.
Thanks to all who attended and tuned into the last Selenium Hangout where we talked about Selenium 3! Below is a write-up of the meetup, the video, and relevant links we mentioned. And to access all meetup videos you can go here.
Panel
David Burns (@AutomatedTester)
Dave Haeffner (@TourDeDave)
Kevin Menard (@nirvdrum)
Simon Stewart (@shs96c)
Video
Minutes
00:00 – 05:04
Goal and items for today’s conversation
Feedback review from last meetup
Intros
05:05 – 07:34
API changes
Packaging
Gradual approach to phasing out Selenium RC
Support for Selenium IDE HTML Suite running
07:35 – 09:55
Selenium Builder, how it will replace Selenium IDE, and when
09:56 – 11:30
Firefox Driver 2 release (a.k.a. “M day”)
11:31 – 12:00
Tasks required to complete WebDriver W3C standard
12:01 – 14:30
Upgrade concerns for enterprise users of Selenium
Recommended watching: Jason Leyba’s talk at SeConf about upgrading Selenium at Google
Reasons why companies should make the jump
14:31 – 14:55
Why we need browser vendors to help
Why the W3C standard makes sense
14:56 – 21:40
Lessons learned and challenges found when a large scale practitioner upgraded from RC to WebDriver
Things they would like to see cleaned in Selenium 3
A nod in support of Selenium RC as a separate download
Simon attempts a joke
21:41 – 25:15
Other changes in Selenium 3
– all or nothing upgrade
– exception handling (changing from status codes to status strings)
– how commands are getting sent across the wire
– philosophy behind approach to Selenium RC approach
25:16 – 27:29
Mobile support in Selenium 3
27:30 – 37:05
Firefox Driver and Firefox OS
Recommended watching: Jonathan Griffin & David Burns’ talk at SeConf on Firefox Driver/Marionette
Creating a common set of Desired Capabilities
Recommended watching: David Burns’ talk at SeConf on adding mobile gestures to WebDriver
37:06 – 38:20
Documentation
38:21 – 49:40
Brief history of Selenium project
Recommendation for RC users to look at the stable and brilliant new and shiny
Plan for Selenium RC in depth and rough timeline
Another recommendation to watch Jason Leyba’s talk at SeConf about upgrading Selenium at Google
49:41 – 50:45
Encouragement for folks to hop on Selenium IRC chat channel (especially if your question wasn’t asked/answered)
Recommended reading: Elemental Selenium’s write-up on what IRC is, how to use it, and how to connect to the Selenium IRC chat channel
50:46 – 51:45
Where to submit feedback and request topics for future meetups
Although the WebDriver APIs started life as just a mechanism for automating web browsers, over the past few years it has been extended to also work on mobile devices. Projects such as Appium, iosdriver, and Selendroid have all shown that this approach works, and works well. On the Web, if you start using Selenium WebDriver with one browser (Firefox, for example), it’s easy to switch out the browser for another one (such as Internet Explorer or Chrome). It’d be nice to have a similar option for mobile, switching from one automation framework for Android to another.
As part of the Selenium 3 work, we have started working on a test suite to help ensure this level of interop between appium and iosdriver, and appium and selendroid. To kick start the process, the primary authors of each of those tools, as well as others including David Burns representing the Marionette project (Mozilla’s implementation of WebDriver for Firefox and Firefox OS) and Simon Stewart, the lead of the Selenium project, have spent the past two days locked in a small room in Mozilla HQ, London. They’ve taken this time to work out the areas where each of their projects didn’t align and agreed on a way to ensure a level of interoperability. There was only a minimal quantity of blood and tears, but plenty of hard work.
The agenda for the past two days can be found here, and the minutes are also available.
As we speak, work has started on a shared test suite, hosted in a repo in the selenium project’s Google Code page. Please, feel free to come along and join in!
Selenium 2 was released in July 2011. It’s now two years old, and what a couple of years it’s been! The WebDriver APIs, which were the major addition in Selenium 2, are now the basis for a W3C standard, and there are implementations written and supported by Google, Mozilla and Opera. There have been 34 releases, with official support for Java, C#, Python, Ruby and Javascript, and the community has stepped in to provide bindings for Perl, PHP and others. There have been 57 different people authoring changes in the code base, and countless more participating in the online forums, offering help and advice.
While all this has been happening, the world has moved on, and now it’s time for the Selenium project to look to the future. It’s with great pleasure that I can now say that we’re working towards Selenium 3.
We aim for Selenium 3 to be “a tool for user-focused automation of mobile and web apps”.
What does this mean? For mobile users, the Selenium project will be hosting a suite of tests to facilitate interoperability between the many different projects available that are extending the WebDriver API to also cope with mobile. Developers from projects such as Appium, ios-driver and selendroid will be working on the suite of tests to enable this.
We’ll also be working on making the technology behind Selenium as stable and capable as possible. For this reason, Selenium 3 will see the removal of the original Selenium Core implementations, and consequently we’ll be deprecating the RC APIs too. The old versions will still be available as a separate download, but active development will cease, except for very urgent fixes. We will still be providing an implementation of the RC APIs backed by WebDriver, so you can continue running your existing tests, but now would be a great time to make the move to using the WebDriver APIs directly.
For those of you exporting your tests from IDE and running the HTML suites, we’ll provide an alternative runner that allows you to continue running those tests too, though it’ll be backed by the same “WebDriver-backed” RC implementation as offered by the main download. Again, the original implementation will be available as a download, but it will no longer be actively developed once we release 3.0.
Our current plan is to start shipping 3.0 by Christmas this year: it’s going to be a lot of fun!
Trying to find every excuse not to cut the grass … including apparently closing some browser tabs.
Brain fried from PyCon Canada 2013 and ‘some’ browser tab is misbehaving which means its time to start closing some of these.
Note from Adam: This is a guest post from Dave Haeffner who, along with David Burns hatched this idea at SeConf2013.
Have you ever wanted to attend a Selenium Meetup but there’s not one near you? Or maybe there is but something’s come up and you can’t make it out that night? Or maybe the meetup near you struggles to get good speakers and have a consistent schedule? [Note from Adam; like, say, the Toronto one…]
Well, what if there were a way to attend a meetup regardless of location?
And what if each meetup you attended was lined with core maintainers of the Selenium project?
And if you missed it, what if the whole thing was recorded and available for you to review at your leisure?
Well, now you can.
Introducing Selenium Hangout — the world’s best and most accessible Selenium meetup. An entirely online meetup that leverages Google Hangouts and live streaming to YouTube. All meetups will be recorded and posted online afterwards.
Each meetup will contain a small panel of people from the Selenium Community (e.g. core committers, automation practitioners, etc.) and they will discuss various topics (TBD).
Simply follow the SeleniumHangout Twitter account to find out more.
A ‘should be scripting, but brain stuck in neutral so closing some tabs’ edition of the Smattering.
Apparently today’s ‘wait for an email’ task is to whittle down the smattering queue some more.
A Sunday Smattering? Sure!
40-ish minutes until midnight eastern so that counts as two days in a row, right? Right?
Almost a month after the last one. Though it did nice to have it at 150 when people go to the blog … but a greater number is nicer.
Yup, this smattering has very little to do with Selenium, but… 150!
Too. Many. Tabs.
Gotta start this up again…
This is a guest post by Marcus Merrell, one of the organizers of the 2013 Selenium Conference.
Selenium/Webdriver has kept my family fed since 2007. Since I’ve never committed a line of code to this magical project, I thought the least I could do was spend a few hours helping put SeConf 2013 together. When they asked for a volunteer to put the speaker program together, I was thrilled to step forward!
Ultimately, I decided on a more conventional approach than straight-up dictatorship–and I can only credit the 5 awesome people on the committee and their ruthless adherence to the principle that “data wins”. I wanted a mix of hard-core browser techs, language-binding mavens, and people who ultimately made their living keeping a large variety of clients happy. And Simon–always Simon. I left myself out of the voting, because these are the experts’ experts: I figured the best thing I could do was ensure a smooth process and remove the burdens of book-keeping.
Here they are, the People You Can Blame:
– Dave Hunt, Mozilla
– Jim Evans, Salesforce.com
– Santiago Suarez-Ordoñez, Sauce Labs
– Jari Bakken, The Matrix
– Simon Stewart, Mt Olympus
I don’t know if it was beginner’s luck, but there was zero drama. These folks are all pros, and we’ve put together a hell of a great conference for Boston.
We had 24 slots to fill, but only ~45 submissions, and without the variety of topics we wanted. Specifically, we were dismayed by the low number of submissions from female presenters. Given a high proportion of female testers in the industry, we believed their voice was under-represented. The call was extended in part to attempt to correct this, and ended up netting us ~20 more submissions in total.
With the proposals all gathered in one place (thanks, Ashley!), I then set about trying to find “themes” in the submissions. Several leapt out immediately–lots of case studies showed up from large household-name companies that I knew people would find interesting. Some deep-dives appeared, describing the inner workings of browser implementations or talking about a new tool-set people might find interesting.
Another theme I saw, a blend of the previous two, were the Best Practices–people who wanted to talk about processes for applying disparate tool sets to the problems we face every day. I believe these talks have the broadest appeal, and are a primary driver of attendance. We also had enough mobile offerings to put together a “bloc”, which will consume a whole afternoon.
Simon suggested “blind auditions” for the selection process, and everyone loved the idea. Voting would take place not knowing anything about the speaker outside of hints left in their abstract. Since we had extended the call to invite submissions from female presenters, we therefore believed this would “correct” for that bias. It should at least remove all doubt that any speaker was chosen specifically for their gender.
I created a Google spreadsheet with a separate tab for each of these themes. Each tab contained only a few columns–the title, abstract, “notes to organizers” (if it was relevant), and one column for each person on the committee to vote. I did not include author bios, and if someone’s name showed up in anywhere else, I redacted it. I *did*, however, leave in speaker’s company. I figured if I saw two talks, “Success and Failure at Google” and, “Continuous Integration with Selenium at Bob’s House of HTML and Gumbo”, it would be completely reasonable to make the decision based on the company.
My thinking was, rather than have each person go through each talk individually, all these folks would have to do is read a paragraph and assign a number 1-5 (1=want, 5=don’t want). That way they would rank the talks in terms of the best subjects for that particular theme, thereby making sure just about anyone would have a good “path” through the conference. The committee was given a short deadline (1 week!) to fill out the voting columns, after which we’d sync up on the phone.
Somehow we managed to get people from California, Texas, Florida, the UK, and Norway into the same Google Hangout at the same time. We averaged the scores into a column in the spreadsheet, and Simon expertly sorted, manipulated, and color-coded the rows. As I said, we had 24 slots to fill, so Simon just drew a line: every talk in every theme that scored below a 2 was “in”. This left us with around 10 talks–we all agreed on two points: a) those talks were awesome, and b) we needed more.
So we cut in the talks with a score between 2 and 3. This put us up to 23 talks, so we had to begin some horse-trading. We started to have some difficult conversations when I realized that I had somehow not scored one talk at the bottom of one tab. I applied the formula to that cell, and it had one of the best scores of all–so we had 24! Huzzah!
Where does this leave us? With 2 days of Track A and one day of Track B. Given 8 presentations per track per day, that leaves us with an entire day of “open” talks for Track B. Be sure to sign up right when you get there–these slots went really fast last year, and will probably go fast again. We also will have a day of workshops on four different topics, with two in the morning and two in the afternoon.
We’d like people’s feedback on how the conference “flows” this year. As I said, we wanted someone with just about any background and interest to be able to find a path through this conference, so I’d like to hear whether or not we achieved it.
…and I hope to see you all in Boston! (PS: Tickets are going fast!).
My. Get. Productive. I know! I’ll push out a smattering. Oh. …
Happy ‘productivity destructive week’ — otherwise known as March break.
Alice Finch builds massive LEGO Hogwarts from 400,000 bricks starts out at awesome and goes somewhere further down the scale when you get to the photo that shows scale.
Real Canadians watch curling instead of hockey.
If you had anything interesting last week I should have seen, you’ll have to resend it to me or @seleniumhq — things were a bit crashy.
Its a Wiggle your brain kind of morning…
Its -12 Celsius plus windchill out. Why the heck is the office air conditioning on. Feel like I need a Mr. Rogers cardigan or something.
Buckets!
I suspect that scanner-backed-by-selenium belongs in the ‘with great power comes great responsibility’ bucket
ios-driver is in the ‘wouldn’t it be nice if Apple provided this’ bucket
Selenium WebDriver utility for determining when page has finished rendering is in the ‘ADF specific’ bucket’
I suspect JSErrorCollector is in the ‘already indirectly linked to’ bucket. If not then its in the ‘FF only’ bucket
Using a business readable language for browser automation is in the ‘bdd/atdd hype’ bucket. But is also in Haskell which is kinda interesting for an Se article
reality is expensive: a better way of thinking about mock objects – Yup. ‘Fake bucket implementation’ bucket.
The bits in Android’s tablet quality page would be even nicer if Android wasn’t in the ‘openly hostile to automate’ bucket.
Data Attributes Rock – As Both Css and Javascript Know Them — HTML5’s data attributes are firmly in the ‘raindrops on roses and whiskers on kittens’ bucket.
Stop Using Story Points gets added to the ‘read the comments as well’ bucket. Also the ‘this is how we accrue automation debt, kids’ bucket.
Large scale automation with jenkins from Kohsuke Kawaguchi
. Oh, and the ‘woohoo! I already do this stuff’ bucket.
Posting from the past into the future. Or something… (its a scheduled post).
This year’s Selenium Conference is slated for June 10 – 12 in beautiful Boston, Massachusetts. The conference will be held at the Renaissance Boston Waterfront Hotel. Similar to last year, this year’s conference will kick off with a full day of Selenium Workshops, followed by a two day, two track conference. If you’ve always dreamed of speaking at a Selenium Conference there’s still time to submit a talk to us at http://www.seleniumconf.org/speakers/.
As we have done every year, we’re pleased to announce that a batch of early bird tickets to the Conference is on sale now, even before the talks have been finalized. You can get your ticket(s) by visiting http://seconf2013.eventbrite.com/. There are only 45 early bird tickets available at the special rate of $299, and they are only available until February 4th, so act now! After that the regular price of $350 will be in effect for all tickets. You’ll also notice that tickets to our workshop day are for sale as well. These cost $75 and entitle you to attend a full day of Selenium workshops on Monday June 10th.
More information on the conference is available at http://www.seleniumconf.org/, and we are still accepting speaker proposals. We’re looking forward to seeing you in June!
<insert snark here>
<insert snark here>
Whoops, missed a couple days… ah well.
This short technical note is to announce that the Selenium project is now using git on Google Code in place of subversion.
The move has been a long time in the making, and it’s largely thanks to the efforts of Kristian Rosenvold that we’ve been able to do the migration and retain the project history. The project owes him a huge thank you! We’re in the process of migrating the last bits and pieces (none of which are user facing), so there may be some last minute turbulence as we settle everything down.
Although the canonical source will be on Google Code (http://selenium.googlecode.com/
), we’re working on setting up a github mirror. We’ll announce the location of that once it’s set up.
Someone go back to my past self and punch him for thinking that starting to get in shape was a good idea. OMGCANTMOVE.
Three in a row … of course, these are the easy three.
Hrm. Office is closed until Monday, but everyone is in. Very confusing…
Since today is the start of ‘find a new contract’ I guess I don’t have an excuse to miss these for the next week or so.
(Oh, and Happy New Year, etc.)
This is snark, but just makes me laugh given the hype machine around ATDD/BDD;
AS an angry userI WANT TO punch the developer in the faceSO THAT I CAN punch the developer in the face.
— Kristopher Johnson (@OldManKris) December 4, 2012
Alright, this is also snark, but Why not make your URLs responsive? is an interesting ‘how would I automate this?’ question
Adoption Of Exploratory Testing And Test Automation On The Rise is kinda sales-y [which is fine given the context], but if you swap in ‘Selenium IDE’ or ‘Selenium Builder’ for ‘TestStudio’ then you have the case for those parts of the suite.
web++ is a single file webserver — in c++
From 15 hours to 15 seconds: reducing a crushing build time is pretty good, though some very obvious developer tendencies sneaking in. The quick fix at the end, run the build entirely on the tmpfs in-memory file system seems in intriguing as well.
Your periodic reminder that Simply Writing Tests Is Not Test Driven Development
Javascript & HTML5 Game Engines Libraries – 51 Examples — and all will need their own unique automation efforts. Welcome to the JS Executor future. Honest, those aren’t thumbscrews you see on the counter over there. Why are you looking at the counter?!?!
HTML5 canvas performance: Drawing circles — timing is something we’ll also have to care about in HTML5 apps.
And I thought my brain hurt before reading display: none;. I was wrong.
2.27.0 is now out which means you can close the browser tab that points to the old Firefox installers.
Not sure how widely broadcast this has been (cus, you know, we’re good at communicating and stuff), but if you are using 2.26.0 and Firefox 17 you will get a nasty bug. 2.27.0 is in the works to address this (and a couple other things…) so if you need FF right now, keep your install at the latest 16 release.
This is pretty decent. Except the usual “Feh! We don’t need humans to test! Automate everything!” bias you see around. Psst kids! Even the poster children for Continuous Deployment actually do Continuous Delivery (humans! shocking!). Oh, and the usual gloss over ‘cluster immune system’ which is the only part of this tend that has an elegant solution.
Running Automated Tests in Parallel – Part 1‘s new bit to me was how to run groups of jUnit scripts from maven. Sure, I think I knew there was a way to do it but never had to think about it before. And as a bonus, here is the video that goes with the post
PHP Sadness is kinda amusing from a language trolling perspective. But also actually really useful. Now for a Ruby Sadness and a Python Sadness. Of course, a Perl sadness would just be a one of those ‘try to click this moving box’ widgets…
Following up on not automating GMail (aside through standard low-level protocols like IMAP or POP3) is a MailBox class for processing IMAP email (Gmail from Python example
I’ll admit that Writing JMeter test plans in Ruby has me pretty excited
But if Ruby/JMeter doesn’t do it for you, then maybe Funload will – How to stress test your app using Funkload — part 1
Search is one of those things a lot of automation get burned by since things are often going in parallel and not casually waiting for someone else to look for something that was just put in the index half a second ago – Moving the Marketplaces to Elasticsearch
I Call Them ControlObjects; I call them Elements, or with increasing frequency ‘Unnecessary Designer Porn’ for the rash of js-widgets-that-look-like-standard-html
I’m kinda amazed I haven’t had to use the regex part of my brain in awhile, but everyone doing automation really needs to have that section tucked away somewhere – A Practical Example of Regular Expressions
Low Power Server Monitoring with a Raspberry is just cool
Can’t get enough Se bloggage? Have a look at Overview of Selenium Blogs — though I must say there has to be something wrong with the Alexa algorithm if I am that far down the list. And behind both David and Alister. 🙂
A hardy welcome back to work to our American friends who spent Thursday being thankful for what they had, then getting into fist fights at stores for things they thought they didn’t need the next day.
…as I avoid writing code that deals with dynamically constructed tables. Without any sort of unique locator. Of course.
Within an hour I had some more things to add to the last Smattering. Oh well, I’ll just save them up…
I’ve been threatening that I was going to do this for awhile…
Right…
Perhaps I’ll do something else right now…
Too. Many. Links. Not. Enough. Posts.
It’s been a long time since we announced a new Selenium release on this blog, as we moved to a model of quicker releases, but we’ve been working on 2.26 for far longer than normal — it’s out! Download it now! — so I thought it best to let you know. We’re aiming to head back to faster releases, so hopefully you won’t see another blog post about the release for a while (though I’m sure they’ll appear in the “Smatterings of Selenium” posts)
Some highlights that you might be interested in, include support for the latest and greatest versions of the popular browsers out there (including native events on Firefox 16!), the deletion of deprecated methods from the language bindings, better emulation of user input on IE when dealing with “sucker fish” style menus, and a slew of bug fixes. There’s more in the changelog!
The inimitable Jim Evans held the Release Bacon for what has become one of our most challenging releases to do, so a big “thank you!” to him. A “thank you”, also, to the rest of the core developers and Sauce Labs team members who worked on fixing so many bugs and getting our continuous build green, especially Alexei Barantsev who did some amazingly detailed and painstaking work to help the release through. And a final “thank you” to our users: thanks for your feedback and support. 🙂
Let’s try the ‘all video’ edition this time.
Hrm. That didn’t work … let’s add some slide decks.
Its the ‘all github’ edition today!
Its that time again, 4th Annual Automation Honors Voting is now open. Vanity contests FTW!
Introducing the Sauce Plugin for Selenium Grid from a product perspective is huge. And in a roundabout way proves I am not completely crazy…
Benchmark of Python WSGI Servers has lots of numbers, and graphs and charts.
Seleno makes some bold marketing statements (‘the RIGHT way!’). Looks like a framework in C# that forces people to use Page Objects
Automating an SVG game with Selenium WebDriver from Andreas Tolf Tolfsen on Vimeo.
Splinter is another python web automation framework. How long until this gets marketed as the next Selenium killer that uses WebDriver under the hood.
If you’re using Maven, maven-notification-center could be interesting. Well, if you are also using Mountain Lion.
And I quote from Acceptance Testing Revisited – Asking customers to read and write acceptance tests is a poor use of their time, skill, and inclinations.. THIS!
OH NOES! Your Credit Card Pin has been leaked!!!!
Testing Automation With Selenium – Part 1 starts with Never send a human to do a machine’s job but also omits Never send a machine to do a human’s job
Dog Show Quality is where “Quality” is its own goal. That’s from about halfway through the article. Hands up when see this with automation all. the. freaking. time. (All your hands should be up. OK, you can put the down now.)
<Insert witty/snarky commentary on something here>
So do people celebrate the day after Labor day as the beginning of summer?
The big news in the twitter-verse yesterday was the announcement of Apple Sauce and Android Sauce from Sauce Labs. I of course jumped all over that bandwagon with Apple Sauce and Android Sauce .. Yummy! (And Fully Supported) * Accessing priviledged Javascript APIs from your web page in Firefox with Selenium lets to pull even more strings of the browser than you were supposed to be able to. Something I suspect Marionette will make redundant, but until then…
Use Xvfb, Selenium and Chrome to drive a web browser in PHP starts with the same-old, same-old, but scroll down to the bottom for squid and iptables and other things
Integrating Selenium with ALM – a simple recipe shows how to do it, but I still say whomever packages this up really well will make a lot of money
You Papers Please is something that will start to come up in the Se community soon-ish I fear.
Emulator Networking is a link I wish I had before spending an hour or so trying to search SO etc. for it
The Axis of Eval is just funny
BrowsermobRESTclient is a Java client for the BrowserMob Proxy
My Shallow Dive into iOS automation looks at the various options out there for native automation
Py.Test is awesome. And makes my brain hurt.
slides:
Funcargs & other fun with pytest from Brianna Laugher
video:
code:
Hurray for having fillings done on both sides of my face. Don’t expect me to speak without drolling for rest of the day.
I’ll admit to not knowing what the difference is/was between FluentWait and WebDriverWait, but FluentWait with WebElement explains it well. With sample code!
PHPUnit + Selenium + php-webdriver = hours of entertainment (Part 1) shows a nice extension to PHPUnit_Framework_TestCase. Now if only he was using my active fork of the php-webdriver bindings rather than the original project Facebook seems to have abandoned.
Speaking of Facebook, Under the hood: Rebuilding Facebook for iOS is going to be oft cited in the whole ‘html5 or native’ discussions for the next while I think
Santi spoke at the recent San Jose Selenium Meetup; video, slides
Automatic Conditional Retina Images seems like something we should know how to check if its being loaded properly or not. Guess I need to go buy an iPad to check this out…
Puppet Labs updated some of their documentation recently; Puppet 2.7 Reference Manual, Factor 1.6 Core Facts
Reddit opensourced push which is yet another deployment tool. Remember though, you are likely not Reddit.
Hey lookit! The WhiteHouse uses Selenium. Though the scripts are Selenese. And named .php for some unknown reason. Actually, they look a lot like they were created as part of some sort of scaffolding. Anyone?
Not sure what to do with it, but Updated List Of Vendors In The Content Delivery and Transparent Caching Markets looks rather useful. Or not.
/me is not looking forward to when the jet lag whallops him
/me is not looking forward to when the jet lag whallops him
Eyes are gross.
When this gets published, I’ll be sitting around the Barcelona airport waiting for my connection home. Unless I screwed up the time math. 🙂
Dear body; what time zone are you in?
Ah well, until that battle resolves itself, here are some links.
Going to be on an airplane for the better part of the next day, so will likely miss some links … unless I am tagged on twitter with it.
Apparently the links are slowing down for the summer?
Back on the train again. Wow, the highway is screwed today.
The Automation Litmus Test is one that most companies face, but now it has a name
Okay, who has more info on the bots mentioned in Meet the ‘bots’ that edit Wikipedia? Highly doubt that they are Se powered, but it is a fun mental image
Custom PHPUnit Annotations is useful magic if you are building out a framework
I’ve linked to things before about where to put things and how to find them, and purpose-oriented tests continues that trend
Moving Towards a Continuous Integration and Deployment Process is a nice explanation of how one team does Continuous Delivery. Notice how they use [human] testers.
The PageFactory is magic. And magic is not always good. As Iain found out..
Now, if someone wants to solve these problems using PageFactory and then update the wiki page…
The Simian Army has been unleashed! (Also know as the Netflix Chaos Monkey)
Rants of a Madman – I don’t care if it’s automation, it’s still code! is full of the ironies that testers inflict upon themselves and their teams
Capturing Performance Data from Selenium Tests is a recording from the July San Diego Web Performance Meetup
I used to believe in the tooth fairy is a nice reminder to be open to changing your mind.
In case you are curious, the train just went past my old neighbourhood.
This was supposed to go out Friday, but the flu bug I picked up decided to move the schedule about somewhat.
I think everyone is on holidays right now…
Seems I had this all ready to go yesterday… oh, and Happy Birthday Jim Evans — maintainer of IE and C# driver. If also a day late.
Apparently my body isn’t quite on left coast time…
Really? A drought for most of the week and now I’ve got a queue again in the span of 3 hours?
Century!
With the queue flushed we’ll go back to our regular random posting schedule
Happy day off Canuckistan! I’ll be in California in two weeks; here is my schedule — come by and chat
Yes. I know. I missed a day. But 13 in a row was a good run!
Blech. Supposed to go car shopping today. Any car brands want to sponsor my wife with a car so I can do something productive? Worth a shot…
Ok twitterverse. After 2 weeks of very few links a day you explode.
# sudo wget coffee > adam
# sudo wget coffee > adam
Selenium-RC Commands is a mindmap of all the commands in Se-RC. (Unsurprising really.) I keep meaning to do this for WebDriver.
quacken is a script for grabbing OFX files from Quicken it seems
What’s that? You weren’t happy with one of the six PHP WebDriver clients that were out there already? Have another one — Nearsoft/PHP-SeleniumClient. It’d be spooky what would happen if we all got together on this.
Thucydides Release 0.8.26 grew Remote WebDriver support (and something to do with Spring but I don’t speak Java)
I don’t know if this is a chop or not, but
Why did the @Lenovo dev call me an asshole? Code review much? twitter.com/RussSolberg/st…
— Russell S (@RussSolberg) June 22, 2012
is hilarious. Well, from a ‘been there, done that, crap I forgot to revert’ perspective.
Yes, packaging is a hard problem. No, I don’t know how to even begin to solve it. Python Packaging: Hate, hate, hate everywhere is kinda a history lesson on what the current state of the world is in Python.
Oh, and because this is what happens on the internets, there is a bigger discussion of the previous article over on Hacker News
inproctester is a standalone J2EE app server for running HTMLUnit WebDriver scripts
Its a bit amusing [though not to a lot of people] how much love parts of WebDriver get from the world at large and how much hatred other parts get. What’s Wrong With the Internet Explorer Driver? enumerates some of the causes, why they got that way, and throws down the gauntlet to Microsoft. Who will promptly do, erm, nothing…
Accept-Charset Is No More seems like one of those browser differences that we should know about.
Did I say 8 days in a row yesterday? I meant 9. Good thing programming doesn’t require counting…
What’s that? Eight days in a row? That’s right…
As you’ll start to see by the timestamps of things towards the end, I’m running out of ‘new’ stuff and am pulling from the queue now.
Eventually I’ll get back on the once-a-week schedule. But not today!
http://concur.rspace.googlecode.com/hg/talk/concur.html
) — also has gophersFigured I would get this out before the computer goes in for surgery.
Five days and fifty links later…
Avoiding punching things about software packaging by doing the 4th!!!! smattering in row.
Look at that! 3 days in a row, and the boy isn’t even gone to school yet and I’ve hit ‘publish’
Two days in a row! Take that doubters!
What? Its only been 3 months since the last one. Sheesh.
Sorry about being a G+ article, but DOM Ready discusses briefly about how to build your page in terms of order of events. Of course, if you read the comments it is very much buyer beware, but…
I’ve been fixating a bit on operational dashboards the last little while and Enterprise Operational Intelligence has a couple good ones
Looking to use BrowserID? There’s a Page Object for that.
Lessons from Etsy: Avoiding Kitchen Nightmares starts with an oven belching flame and gets better from there
Roll your own page objects, is, for the record how I do Page Objects too. Well, aside from using something like Cucumber as just a functional runner
Rachmaninov’s Third Piano Concerto, Played by Selenium is just cool
Splitting Robot Framework tests into batches for parallel execution is one solution to the ‘my batches were balanced but now they are not’ problem
The Long Tail of Technical Debt shows one way of parsing run information and suggests what do do with this particular outcome pattern
Bugwatch is magic, but magic can be fun too! Well, sometimes.
And lastly,
When test automation is made a goal rather than a tool, quality suffers. — Ben Simo @qualityfrog@mastodon.social (@QualityFrog)
It’s been a while since the last Selenium release, but I’m happy to announce that Selenium 2.22 is now available for download. This is a big release for us and features two major changes.
The first is that Selenium 2.22 is the first version that requires Java 6 in order to run. This has been the case for the Selenium Server for some time, but this is the first time the client code has required Java 6. Since Java 5 was “end of lifed” in 2009, we don’t expect this to impact many users.
The second major change is that we are now providing a standalone IE server for use with the WebDriver API, similar to the one used by the chrome driver. You can get it from the normal download page. This will allow us to update our IE support independently of the rest of the library (again, mirroring how Chrome is supported) For now, there’s a legacy fallback mode you can use that’ll use the same DLL we’ve always used which can be activated by setting the DesiredCapability “useLegacyInternalServer” to boolean “true” when requesting your IE Driver instance.
Of course, as well as these major changes, there’s the usual host of updates and improvements. We’re continuing to refine the new SafariDriver, and we’re happy to announce native events for Firefox 12. You can check out the other updates in the CHANGELOG.
In this series of blog posts we’ve introduced one of the keynotes and talked about some of the great presentations you’ll see at Selenium Conf ’12, but so far we’ve missed the most important aspect of the entire event: you.
For me, one of the highlights of any conference is the chance to meet other members of the community, make new friends and talk about all things interesting (and perhaps even tangentially related to the conference!) To help this process along, we’ve avoided scheduling everything down to the last minute. Instead, we’ve left plenty of time in the B track for an unconference. You’ll get to pick the talks and have a chance to have your voice heard. Last year, there were some great talks on the equivalent track, and I think we’ll see the same this year too!
If the idea of standing up and talking for 30 minutes in front of an audience seems a little daunting, you can dip your toes in the water by volunteering for a lightning talk: 5 minutes of concentrated goodness! Come prepared with a topic and perhaps a handful of slides 🙂
It’s not all formal talks, either. As well as the many members of the selenium community who’ll be attending the conference, there will be many of the core development team. There’ll be a chance to ask Simon why we’re not using git yet, get feedback on some of the ways you’re using Selenium, or just chew the fat. There will be a drinks on the 17th at a London pub, too.
I’m really looking forward to meeting all of you, and hearing the tall testing stories, and finding out how you’re pushing the boundaries. of web automation. If you’ve still not bought a ticket, there’s still time to. Come along and join us! If you’ve already bought your ticket, what kind of things are you looking forward to?
I may be biased, but I think Selenium Conf ’12 is going to be great. There are talks aimed at every level of Selenium user. We’ve got experience reports, so you can learn from the trials and tribulations of others. There are talks about using Selenium in unusual ways, such as performance testing, or automated security testing, so you can see new ideas and approaches.
There are technical talks, such as the one Jim Evans is giving on lessons learned from developing the IE driver, so you can learn a little bit more about how Selenium works and Luke Daley’s talk about Geb is bound to be fun.
If you’re a fan of Selenium IDE, then the talk on the SauceBuilder will be a “must see”. We’ll also have the current owners of Selenium IDE attending the conference, so you’ll get a chance to pick their brains on the future of the tool.
If you’re someone who enjoys living in the future, then the mobile focused talks, such as Andreas Tolf Tolfson’s talking about OperaDriver on mobile devices, or Dante Briones talking about testing mobile apps on iOS will be interesting. And Jason Huggins will be talking about robots. What’s not to love?
Better still, we’ve left space in the schedule in Track B for an unconference. If you put forward a talk this year that wasn’t accepted, or if you’ve got something you feel the Selenium community should hear, now’s your chance! If you’ve only got a little to say, or just want to make a single point, then you’re really going to enjoy the lightning talks!
All of this is available for the cost of the ticket, which you can still buy. Don’t wait! Come to #SeConf!
The tickets for Selenium Conf ’12 are still on sale for about another week, so there’s still time for you to buy your tickets. In case you’ve not already gone to the conference site to see the great line up, this week we’ll be letting you know what to expect!
I’m really pleased to announce that Liz Keogh, who is a core member of the Behaviour Driven Development (BDD) community and is one of the stalwarts of the London Agile community, as well as a haiku poet, is going to be one of our keynotes! If you’ve ever seen Liz speak then you’ll know just how much a treat we’re in for. She’s got great things to say and always says them in a thoroughly engaging way.
Liz’s keynote is titled “How to Test the Inside of Your Head”. When we test code and find it doesn’t do what we thought it did, we change it. But, she asks, wouldn’t it be great if we didn’t have to write the wrong code in the first place? In the talk, Liz will show how we can use examples and scenarios to break the models we make inside our own heads, helping us to avoid premature commitments and their follow-through – whether in code or in life.
I’m really looking forward to it! I’m sure you are too.
Well, might not be in Florida, but how about them juggernaut Blue Jays?
Someone explain to me why I’m in Toronto and not Florida?
Its March Break (at least here) which means its also Catch Up Week. An extra long Smattering every day!
Good news, everybody! Selenium Conf ’12 is getting closer! We recently selected the speakers for the conference, and it’s going to be a great mix of talks, spanning the full range of subjects from the very practical to the deeply technical. I’m promised that there will be robots.
Selenium Conf isn’t just about the planned talks, it’s also about the community. On the final day, there will be an unconference, so if there’s something you feel passionately about and feel the world should know, now’s your chance. You’ll not only have a chance to talk to and meet other selenium users, but also many of the core team members.
The conference runs from the 16-18 April in London. Tickets are still available! We’re looking forward to seeing you there.
The first code checked into the Selenium project’s public repository was in November, 2004. We’re now in 2012. In the intervening years there have been many browsers released. The last browser we officially stopped supporting was Firefox 2.0, and it’s time to review the list of browsers again.
We periodically review the list of supported browsers as the more changes there are between the oldest version of a browser that we support and the most recent, the harder it is for us to add new features and maintain those that already exist. Balanced against the cost of maintaining the selenium code base itself are your tests; we know that your users might not be updating their browsers to the latest and greatest, and we know that you’ve still got to prove your app works on all the browsers that are important to you. That’s why what’s below is just our plan, and we’re talking about it now to let you have your say.
Looking at the market share of the browsers out there helps us make an informed choice about what it makes sense to support. This will most likely mean:
Firefox: the Firefox market appears to be split between those on 3.6 and those on the new rapid release schedule. Given this, we are thinking of officially supporting Firefox 3.6, and the last, latest and next release of Firefox (currently Firefox 9-11) as well as any ESR releases. The market share for Firefox versions 3.0 and 3.5 is tiny, and the effort to keep them working with selenium is disproportionately high.
Internet Explorer: Despite Microsoft’s efforts, IE 6 is still a popular browser, particularly in the workplace. We will continue to support IE versions 6 and up.
Safari: Safari 3 is now ancient and has been superseded by newer releases. We plan on only supporting Safari 4 and 5.
iOS: We’ll continue to target the most recent iOS release.
Android: Due to some technical limitations in previous Android releases, we are targeting Ice Cream Sandwich and onwards. We will continue to make available the testing framework for Froyo, but will not be making any changes to it.
These are only our plans. If you really need those browsers, and (better!) can help us maintain support for them, then please let us know.
You’ll notice that Opera and Chrome are not listed above. Since Opera and Google now maintain the drivers for those browsers, they are best placed to decide which are the supported versions, but in summary, Google support the major Chrome release channels (stable, beta, dev and canary) and Opera suggest using Opera 11.6+.
If you’re using Selenium RC to test websites hosted on a secure site (accessed using a URL starting with HTTPS), we strongly recommend that you upgrade to Selenium 2.19. This is because the Cybervillains certificate in previous versions will expire soon, and has been replaced in 2.19 with an updated one.
Our thanks to Patrick Lightbody, Ivan De Marino and Mark Watson and Neustar for taking providing the new certificate and the patch!
I should have learned not to boast about getting caught up with links.
And my post that I’m going to link against is a bit of a rant around how to choose selenium training. Though it has also been pointed out that a lot it applies outside the scope of Selenium as well.
You might be pleased to hear that Selenium 2.19 has been released (download it from here!). There’s one big user facing changing that we’d like to tell you about: the webdriver-backed selenium can now be used in supported languages.
By providing this capability, it’s possible to migrate from RC to the WebDriver APIs without rewriting all your tests in one fell swoop (which must be a Good Thing, right?) An example of how to use it in Python would be:
driver = RemoteWebDriver(desired_capabilities = DesiredCapabilities.FIREFOX)
selenium = DefaultSelenium('localhost', 4444', '*webdriver', 'http://www.google.com')
selenium.start(driver = driver)
Provided you keep a reference to the original webdriver and selenium objects you created you can use the two APIs interchangeably. You’ll see that the magic is the “*webdriver” browser name passed to the selenium instance, and that we pass the webdriver instance when calling start().
We hope you like it!
PS: I have no idea why this is the Prancing Unicorn release, but it’s been a while since we named one 🙂
The only links left now are ones currently open in tabs right now. Hurray!
And my post this edition is WebDriver and Meta Tags.
Look! A light at the end of the tunnel!
And today’s post of mine is WebDriver and Cookies which explains how, well, cookies and webdriver play together.
No. Really. A Smattering every day this week and I’ll have the link queue cleared.
Go!
One thing I have done in these Smatterings is to not link to my own stuff, but am going to start linking to an article or two at the bottom of the Smatterings (unless there is general community backlash against the idea).
Post ten links, find seven more to add to the queue.
And home. Which mean 100% more internets! Or at least 98% more.
It is kinda hard to do these without reliable internet… dear hotels, fix. your. internet.
Two Ruby gems
A three-parter on building a framework showing there is more than one way to skin the framework cat.
Another three-parter on Is the Cost of Continuous Integration Worth the Value on Your Program? – part 1, part 2, part 3
31 Days of Testing – in 23 parts (though I expect the series will finish after CodeMash)
The secret history of “about:jwz”, “about:mozilla” and the Netscape Throbbers is just a fun browser history read
Pulling Jenkins’ strings with Puppet looks like a way of managing Jenkins instances through puppet — which is darn cool.
Given When Then is a BDD tool for Node.js which does its post-conversion-magic runs using WebDriver (please stop calling it Selenium 2!) and Sauce Labs
Selenium Utility Funcs is a list of python helpers (with slightly friendlier names) for WebDriver
Converting Gems shows a neat trick for converting ruby gems into .deb files so they can be installed and managed via apt
Since we all care about the web, Move the Web Forward – You love web standards. You want to give back to the community. Curious about where to start?
It’s been a while since we last blogged about a Selenium release. Since the release of 2.0, we’ve been attempting to give you a fresh and shiny Selenium release every week (though, in reality, we’re managing to get you one every 10 days on average). This allows you to pick the version that’s most suitable for you and your teams, but provides a route for quick feedback on how we’re doing. I think we’ve now ironed out a lot of the initial problems and bumps we ran into, so we are extremely proud to announce the release of Selenium 2.16.
If you’re unsure about what’s been happening since the last time we announced a release here, the best place to look is our changelog (http://selenium.googlecode.com/svn/trunk/java/CHANGELOG
). The most notable feature in 2.16 is better support for Firefox 9, but if it’s been a while since you’ve last updated, we’ve been beavering away on bug fixes and making existing features work as flawlessly as possible. Now’s a great time to update!
One of the key tools we use for assessing whether it’s okay to push a release is our continuous build. This watches for each and every change made to the project’s source code, and runs an increasingly vast suite of tests to verify that nothing has broken. Our friends at Sauce Labs have been extremely generous in providing support for this, and have worked closely with us to make the build as stable and quick as possible. Special kudos and thanks to them!
January means its time to escape from under the deadlines I found myself under during December so some of this stuff is a month old (or older!). Hopefully it is still interesting though.
The community around Selenium is the thing that really makes the Selenium project special. Last year, we held the first official Selenium Conference in San Francisco, and it was both great fun and a huge success. It is therefore with great pleasure that we are announcing Selenium Conf ’12! It’ll be taking place in London from the 16th to the 18th April, and we’re really looking forward to seeing you all there!
If you’ve been following @seleniumconf on Twitter, you probably already know that we have some early bird tickets available and the Call for Papers is open. We’re looking for everything from lighting talks, through traditional presentations, to half-day long workshops on anything that uses Selenium in any way, including building on the Selenium WebDriver APIs (so talks about Watir would be welcome too!). It’ll be a chance to show off what you know and learn from the experts. If you get a quiet moment during the Christmas break, why not put forward a talk? If you’re not a talker, but can help us with sponsorship, we’d love to hear from you too!
Just as last year, the workshops will be happening on the first day of the conference, but places are limited. We plan on running a total of four workshops across two tracks, meaning each workshop is half a day long; a fantastic opportunity to take a deep dive into a particular area of the project. The early bird tickets give you access to them, as well as the conference itself on the 17th and 18th.
The conference will consist of a main single track with selected speakers, with break out rooms being dedicated to an unconference, the contents of which will be decided by attendees. It’ll be your conference, help us make it brilliant 🙂
Looking like there might also be one later in the week too…
That’s it for this week. 🙂
In honor of this edition I provide…
…in which I also date myself.
Its been almost a month, so time for a flurry of Smatterings.
We’re pleased to announce the release of Selenium 2.9. As well as improving the stability of Grid under high loads, we’ve added an experimental (and temporary!) feature that allows the Firefox driver to use a different mechanism for determining when a page is loaded. This is designed to handle the case where the driver appears to hang, as it’s waiting for all incoming requests to complete before continuing. How to enable this mode is listed in the changelog.
This release also includes an updated Android driver, allowing your tests to run on Ice Cream Sandwich devices.
Aside from one of the dog’s tummy making noises that imply a big mess to clean up later, this scheduling thing seems to be working out.
Heard someone talk about doing bitmap comparisons last week somewhere. Adaptive Images tricks I suspect are going to become more commonplace. Good luck with that. Se is best at interaction, structure and content checks; not does-it-look-the-way-some-human-intended. Robots where robots should be used. Humans where humans should be used.
Interacting with a Javascript confirmation from Selenium in Cucumber
Converting Selenium waitForCondition to WebDriverWait sends you along the path to understanding Waits in WebDriver
Splinter seems like a wrapper about the Python WebDriver bindings
Making a Mockery of TDD starts with To be a successful mockist, you must dislike mocks. which I think is just as important when doing Se. The res of the article is good too.
Integration Testing with RSpec, Capybara, and Selenium includes this gem
Integration tests can be brittle if they know too much about how those components work. Proper integration tests use your application as a black box. They should know as little as possible about what happens under the hood, they’re just there to observe and interact with the interface.
I seem to think I already posted this, but the search isn’t finding anything. Here is a visualization of the commits to Se.
The GoogleWebmasterHelp channel on YouTube is full of ideas that you could include in your scripts. At least from an SEO perspective. And Google SEO at that.
The theme this week seems to be GIL. So here is About concurrency and the GIL which for once is about Ruby.
The whole ‘Facebook switching from Watir’ thing produced at least one good rebuttal; Facebook, Watir And Testing
Trying something new; queuing up the catch-up post while I have time to catch-up.
How did I fall behind again already?!?!
In keeping with our (roughly) weekly releases, Selenium 2.8 was released today (and on Maven too), with a *huge* list of bug-fixes! As well as improved stability, if you’re using the Java API, this release adds the ability to upload files to a RemoteWebDriver server (see RemoteWebDriver.setFileDetector (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/remote/RemoteWebDriver.html#setFileDetector(org.openqa.selenium.remote.FileDetector)
)).
Particular thanks have to go out to our two newest committers, Alexei Barancev and Ajay Kemparaj, for the copious bug-fixes they’ve contributed!
We’re already hard at work getting 2.9 ready for next week with even more more bug-fixes – watch this space!
All opinions, all the time…
‘These are the people in your neighbourhood…’
This instalment of catch-up week is brought to you by the letters C and I.
Its been a month and a half since the last one of these, and the volume of links I have collected illustrates that. So this week is now a cleanup week.
How Browsers Work: Behind the Scenes of Modern Web Browsers seems to be one of those articles that people who automate browsers for a living should be familiar with.
100% Test Coverage is always the goal.
Continuous Deployment and Data Visualization reminds us that if some data is good, more is often better.
This is for JUnit, but the ideas apply to any runner.
JUnit Kung Fu: Getting More Out of Your Unit Tests
View more presentations from wakaleo
Database Cleaner is a set of strategies for cleaning your database in Ruby. I think you should just let your database get dirty (since that’s what happens in production) but I’ll give that there are scenarios where that’s not desirable.
The Zen of UI Testing with Selenium, Hudson and Sauce Labs illustrates a nice switch in the @Before method to run either locally or in the cloud (in this case with Sauce Labs). Limiting your framework to be always in the cloud or always behind your firewall is silly these days.
What’s wrong with Ruby’s test doubles? has good overview of the types of test doubles there are. Front-end automation should be generous use of the ‘Stub’ brand I think.
Automation is programming. And Page Objects are OO. So How to Design Classes is pretty darn interesting.
The Samuel L Ipsum really needs an API so we can use it as a random string generator for automation.
For one project I’m working on, I am validating whats in the browser with a JSON feed. JSON Formatter has been a saviour the last week.
If you’ve been watching this blog carefully you’ll have noticed that the last release announcement we made was for 2.3, so it may come as a surprise that we’re announcing that 2.6 has been released (even on Maven!). Don’t worry: 2.4 and 2.5 were released on time and without muss or fuss. 2.6, on the other hand has been almost three weeks brewing.
Selenium 2.6 introduces a raft of improvements and stability fixes. Kristian Rosenvold has been working wonders on Grid 2.0, addressing many reported issues and cleaning up the implementation. In the finest tradition of the project, I now owe him a dinner for his hard work. Thank you, Kristian!
For those of you not using Grid, as well as the normal suite of bug fixes, Selenium 2.6 now supports all versions of Firefox from 3.0 up to 7. For those of you using Java, there is an ExpectedConditions (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html) class that supplies many useful criteria when using the [Wait](http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/support/ui/Wait.html
) and WebDriverWait (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/support/ui/WebDriverWait.html
) classes. The packaged version of the OperaDriver has also been bumped to 0.7.2, which works hand-in-hand with Opera 11.5 and above.
We’ve also spent a considerable amount of time and effort working out the kinks in the Advanced User Interactions API (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/interactions/package-frame.html
). We’d love to hear how you’re using it, and what the gaps are that you can see. For more details about what’s changed, have a look at the release notes.
The release frequency has dropped recently, but we’re planning to head back to weekly releases from here on in. 2.7 is just around the corner!
And here we go again with more links than I thought I had collected…
There are a metric tonne of site on the internets which are on how to scam your way through a Se interview. Hiring Selenium QA people provides some fodder on how one could look for and hire Se folk.
Why I don’t use spork reminds us that pain is [sometimes] a good thing.
The Jenkins project is having a conference on October 2 in the same hotel that SeConf was held.
So long, farewell, and thanks for all the automation lessons learned (or: o hai beautiful Page Object Model AMO Selenium tests!) could win the prize for the longest title ever. And has a good lessons learned section at the bottom.
Selunit lets you run your Selenese inside something like Jenkins
ATDD is still ‘the next big thing’, but Raconteur seems pretty darn cool. If I worked in C# that is…
From Agile 2011 we have
Continuous Integration, the minimum viable product
View more presentations from Julian Simpson
Pay close attention to the database section. I’m getting more and more convinced that this is the part that most companies can benefit the most from.
How to get the args of a function in Python is one of those geeky things that is super helpful and likely a smell that you are trying something you shouldn’t be at the same time.
Is your test automation actually agile? A Guardian Content API example. is part two of one linked in the last Smattering. And the last paragraph is so full of win.
Our friends at Watir have released Watir 2.0. Congrats!
I’ve not tried to run Cucumber in Jenkins, but explains how to do it should you have need
More people should make logos out of lego.
Waiting for elements when UI-testing with WebDriver and EPiTest explains a bit about the WebDriverWait class and has The road to UI-testing hell is paved with Thread.Sleep which would get it linked to in any event.
One thing that keeps getting brought up around WebDriver is ‘how do I get the http code of a request?’. The short answer is you don’t. The long answer is you have to do something like HOWTO: Collect WebDriver HTTP Request and Response Headers
How Cadence Predicts Process reminds people to look at all parts of the process when speeding things up
When building frameworks or DSLs it is useful to know how to make things as deprecated. deprecatable is one way to do it in Ruby
Exploratory Testing in an Agile Context is another session handout from Agile 2011.
#Selenium Tales from the road part 1 – Artifact Naming and Organization describes one way of organization your Se stuffs. That you need a convention I think is exactly why you should use dynamic suites via tags, but…
The PyCon US 2012 Call for Proposals is now out.
Continuous Deployment of iOS Apps with Jenkins and TestFlight describes how to build iOS apps in Jenkins (and if you want, pushing them up to TestFlight)
Why oh why am I only just discovering requests which makes Python’s urllib2 usable.
How to be a faster writer isn’t about writing scripts or code, but its ideas are still sound.
I pretty much refuse to read anything in ACM format, but On the Criteria To Be Used in Decomposing Systems into Modules could be of interest to someone without my biases.
An Inside Look at the GIL Removal Patch of Lore is the geekiest bit of writing I’ve read all month.
I had forgot how much I enjoy purpose built sites like Is the internet down?
I did a webinar on Page Objects the other week for which the video is now available. Its not embeddable, but there is at least a link around the registration wall above the form.
Phew. The links made it through the Lion installation.
Rather than surprising the general community in ways that we have become somewhat known for, I figured I would try something new. Actually asking about usage of things before changing them in fundamental ways.
To this end, I have created a quick(!) survey about changes that are under consideration regarding UI-Maps and how Se-IDE is opened.
The survey is only two questions, so I’m hoping for a large response. I’ll post the results next Monday (August 8, 2011).
One more time for good luck, the survey is over here.
Continuing our new tradition of weekly releases, we’re very pleased to announce the release of Selenium 2.3. The release notes for this version are pretty slim:
We’ve also fixed bugs, one of which was being a nuisance for users of IBM’s JRE. The complete changelog can be found in the zipped downloads or in our source tree (http://selenium.googlecode.com/svn/trunk/java/CHANGELOG
).
If you’re a Chrome user, then it’s a great idea to head over to the Chromium project’s download page to pick up the executable used by the ChromeDriver. It’s recently been updated, and now includes support for handling alerts and prompts! Thanks, Google!
Safari is starting to whinge about how many tabs I have open which means it is time for another post.
Ripple-UI is a cross-platform, mobile web application emulation environment. From RIM. Could be something interesting.
Tips From Our Codebase To Help You Write Reliable Selenium Tests has nothing I don’t violently disagree with. And makes me think we should just add Implicit Waits to the Se Server and be done with it.
WebDriver does not support Sizzle’s extensions to the CSS standard. As it rightfully should not. But it you really want to, you can do something like Creating a Sizzle CSS Selector handler for Selenium2/WebDriver in Java.
One of the things that Sizzle adds is :nth. Instead, we should likely start to think about is :nth-child. Useful :nth-child Recipes
Follow Up to Maintainable Automation ends with A long-term automation strategy isn’t just about writing great tests that help you deliver awesome software, it’s also about keeping your sanity as your software and tests evolve.
On the PageObject Pattern attempts to write up the Page Object Pattern in ‘proper’ Pattern format
CI systems are all about communication. And desktop monitoring apps can assist in that. And if you are using Jenkins then Jenx seems neat
How to use RobotFramework with the Selenium Library is a step-by-step tutorial for getting your first automated specification working.
rsel provides a Slim fixture for running Selenium tests, with step methods written in Ruby.
Slides from the latest SFSE..
The new Testing Pyramid is great.
Reliable tests with Selenium WebDriver
Slides from a webinar I gave yesterday.
I’ve seen a lot of keynotes. Most suck, this one doesn’t.
[blip.tv http://blip.tv/play/AYHluEYC%5D
Improving developers enthusiasm for unit tests, using bubble charts is just cool
Google Chrome joins Simpletest Selenium framework for Drupal
Have a hard time finding unique CSS Selectors? CSSelectify Firefox plugin to help you locate unique CSS Selectors on a page could help
Don’t use IDs in CSS selectors? has some insight into how CSS actually work.
An Experience Report: Feature Toggling — which of course you should be using to turn off all the 3rd party crap that slows down your site during runs.
The feedback from the last release was heard loud and clear: little and often it is!
We’re proud to announce the release of Selenium 2.2. What’s new this time? For many users, this is simply a bug fix release as there are no new major features. One thing you might appreciate is better exceptions (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/IllegalLocatorException.html
) being thrown when xpath searches return something other than a web element when using the WebDriver APIs, and we’re continuing to tweak the emulation of user events.
If you’re a .Net user, there is now an official NuGet package, and if you’re a maven user then rest assured the release is heading to the central repo as quickly as we can manage.
Last week we released Se-IDE 1.1.0 which now features WebDriver formats and Se 2.1.0 was released about an hour ago. Simon will post something shortly-ish on what’s changed.
I haven’t messed around with HTML5 goodies yes, but fake-html5 seems like it could be interesting.
The Yii framework has grown WebDriver support. Now if only there were not two competing PHP implementations for them to have to choose from…
If you are using Python’s native packaging system to share your framework, then Lies, More Lies and Python Packaging Documentation on `package_data` could spare you some headache
This presentation kinda needs someone in front of it to make it fully understandable, but they chose great photos so I’m including it.
View more presentations from Fabio Fabbrucci
Sikuli on Selenium- A demonstration of automation using selenium and Sikuli (such as flash uploader) uses Sikuli where one might normally have used AutoIT but can’t get a handle onto the window. ….And with that use case for Sikuli arrives.
Ever wondered what you get when you cross alcohol and Se? Wonder no more.
Visual Studio seems like overkill for Python work, but if thats your cup o’ tea then Python Tools for Visual Studio is for you.
Creating users for the duration of a run is a problem a lot of systems have. But not with Facebook which has a Test Users API it seems. Don’t forget that you can use this idea internally in your apps too.
With the release of Selenium 2, the project is focuses not on being a browser test platform, but a browser automation one. The difference can be subtle but one area of big difference is in terms of network information details. Selenium RC has support for it, but Selenium WebDriver does not. And of course the latter is the future of the project. 99% of the time, you really don’t need the network information, but in that other 1% the official response to the problem is use something like the BrowserMob Proxy which also had Ruby bindings released this week.
Now that Selenium 2 has been released, one of the goals of the project is to provide regular updates to our users and the community. The aim is for these updates to be small and manageable, incrementally addressing issues and problems raised by you. Selenium 2.1, which is launched today, marks the first of these regular, small releases.
Selenium 2.1 is largely focused on improving Grid with a host of minor improvements including better tracking of “orphaned” browser instances. There are also some bug fixes in the Firefox and IE WebDrivers, particularly when dealing with elements that are just off screen, and in making the Selenium RC emulation in the Java bindings more robust when confronted with pages that haven’t started loading.
As you can see, this is a “bite size” release, but we’d love to know: would you prefer these small, swift releases or larger ones? Please answer in the comments, or on the mailing list!
Two Smatterings in two days?!!? That never happens. Well, except when I get behind and have a metric tonne of links queued up.
Well, since the last Smattering there hasn’t been much in the community. Oh. Well, except for hitting the 2.0.0 milestone. Which seems like a good time to remind people that:
And with that soap boxing, here are some links for your consumption.
We are very, very pleased to announce the release of Selenium 2.0. If you’ve been waiting for a stable release since 1.0.3, now’s the chance to update. And if you do, what will you find?
For users of Selenium 1, this is a drop-in replacement. You’ll find support for modern browsers such as Firefox 5 and IE 9, as well as a wealth of bug fixes and stability improvements. That’s one reason to update, but what other reasons are there?
The big feature of this release — and the reason for the new version number — are the new WebDriver APIs for Python, Ruby, Java and C#. These have been in development for over four years, and are already widely used, trusted and depended on. The WebDriver APIs have been written by developers familiar with each language, so they feel like they belong there. We’re very proud of them, and hope you enjoy using them.
Support for WebDriver is also baked into Opera and Chrome, and we’re working closely with Mozilla to ensure that their browsers also support it. Looking to the future, WebDriver also works on both Android and iPhone, allowing you to test your sites on the next wave of the Web.
As well as support by the browser vendors, WebDriver also provides excellent emulation of user inputs using something we call “native events”. Normal browser automation frameworks, including older versions of Selenium, simulate user interactions via the Javascript engine of the browser. This approach is error prone as each browser has its own quirks. “Native events” are fired at the OS level instead, avoiding a large amount of browser-specific complexity.
Advanced Selenium users will be pleased to hear that the standalone selenium server also includes support for distributed testing via Selenium Grid. This new Grid implementation supports testing using both the original Selenium API and WebDriver, and has been developed as a collaboration between the current Grid maintainer and an engineer from eBay.
We’re working hard to ensure that Selenium IDE also supports all these new features and APIs. IDE version 1.1.0 should be released next week, with support for exporting to the four main languages supported by WebDriver. Please keep an eye on this blog for announcements! There will also be follow up posts, exploring and explaining each of the new features, and providing you with more information.
Of course, Selenium 2.0 is a major milestone, but we’re not done yet. This release marks the point where we expect our APIs to change very little from now on and where we believe it’s a solid release. Like all software, it has niggles and bugs, and we’ll be focusing on addressing these as your feedback comes in.
As a personal note, I’d like to say thank you to each of the many people that have worked so hard to make this the best Selenium version yet. Not only the developers but also the team working on making our documentation clear and easy to read, everyone who’s taken the time to report bugs, and also to you; our users and community. The project is great fun to work on, and you’re the reason for that. Thank you!
The ChromeDriver is composed of two major pieces. There are the client APIs, which you use in your tests, and there’s a server part, which the client APIs know how to start and run and which takes the form of an executable called “chromedriver”. The server piece is maintained by the Chromium team, and they’ve just released a new version, with support for Chrome 14 and with bug fixes. If you’re using Selenium 2.0rc3 and you’re also using the ChromeDriver, head over to the Chromium project’s download page for the latest and greatest!
Last week we quietly released Selenium IDE 1.0.12 on the website. It has Firefox 5 support along with other improvements. See the release notes and unofficial announcement. Download it here or ask Firefox to check for plugins updates.
And for those who did not download 1.0.11 (it was not pushed through the update system) you will want to read about the formatter change that landed.
Welcome to the Canada Day edition of the less-than-weekly-now collection of Selenium / Automation links that is the Smattering of Selenium.
When we pushed the 2.0rc1 live, we really hoped that the next release would be 2.0 final. We very quickly got some feedback that encouraged us to push a 2.0rc2. Now, after just under three weeks, we’re launching a third and final release candidate. You can download it from the Selenium HQ site or directly from Google Code.
We think we’ve addressed many of the common issues, added some polish and added a host of bug fixes and minor changes, and we hope to hear your feedback! The following headline changes have been made in Selenium 2rc3:
http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebElement.html
) or to the Actions (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/interactions/Actions.html
) class.http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebElement.html#getAttribute(java.lang.String)
) instead.http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebElement.html#setSelected()
) and “WebElement.toggle” have been deprecated. They will be removed in the final release.As with almost all releases, there are still some issues left to resolve, but we’re working hard to make Selenium 2.0 as good as it can be.
Two big releases last week…
And the rest.
Python’s super() considered super! begins with If you aren’t wowed by Python’s super() builtin, chances are you don’t really know what it is capable of doing or how to use it effectively. and goes from there.
Want to know what the top 100 issues that have been logged for Se according to the number of stars that have been given them? Click here and wonder no more
[Successful] automation is code, so Why Code Readability Matters is important. Especially since a large body of people writing automation would not consider themselves programmers so missed a large part of the implicit learnings that comes with it.
Tech Talk: Michael Deerkoski (Flickr) — “Continuous Deployment at Flickr” from Talks at LinkedIn on Vimeo.
The State of Ruby and Testing has graphs and such around some survey results around testing in the Ruby community. What is it with Ruby and their love of testing frameworks? 🙂
The future of testing Se-IDE lies with Mozmill. If you are interested in knowing how to run its own tests see Running the Selenium IDE Mozmill tests — and then start to add your own.
What is the most under-used part of Se you ask? Rollups! Which could be thought of as macros and an example can be found here. Rollups btw, will be moved into an Se-IDE plugin at some point.
How can I learn to automate my testing using Selenium? is designed to be Google link-bait and I can’t help but think that is a good thing. I would probably have switched Step 4 at the bottom to be ‘Create Page Objects with the help of the generated code’ or something like that. It’s not really a ‘Best Practice’ to take the raw generated code and run it anymore — if it ever really was.
When most people think of “the browser’s cache” they envision a single map of HTTP requests to HTTP responses on disk (and perhaps partially in memory) from Chrome’s 10 Caches shatters another idea I held. Sigh.
Hey, where’s my unashamedly ugly wait asks the question, then answers it. Sorta. Of course, the answer is in Java so is still ugly…
So does Se have a story around Symbian? Asked due to Top Smartphone Platforms in Europe
The depth and breadth of Python ends with Maybe I should just cancel all weekly meetings and sign off from all mailing lists and focus on two things: meeting Python users and coding. — more people should do this I think. Well, at least the first part.
From a SeConf2011 Lightning Talk is the Annotated Smattering of Selenium Tips
Integrating JUnit tests with HP/Mercury Quality Center – part one, part two
The Apple Testing Problem raises a good point (from Gartner! I know!) — of course, they don’t talk about the cause, which is Apple’s lack of participation in the outside world. It would be great if they would help with the automation driver for their core browser tech, but so would a lot of things that don’t seem to be likely.
I usually don’t link to my own stuff here, but I did a webinar for PustToTest last week and the video of it is now online. (Webinars are weird.)
You win some and you lose some. We’d been really pleased to get Selenium 2.0rc1 out, so we were pretty disappointed to hear that some of you were running into problems with the Java version of the IE driver not launching IE sometimes. That’s definitely not good, so we fixed the problems and have released Selenium 2.0rc2. It’s the same as rc1, but with fewer problems 🙂
We’re still very keen to hear your feedback! Let us know what you think!
We’re very happy to announce the first Release Candidate for Selenium 2, available for Java, C#, Ruby and Python. The API has been stabilised and the functionality needed for the final 2.0 release is mostly in. We’re going to be working hard to get there as soon as possible, but now’s the perfect time to test the waters and provide us with any feedback you may have! Grab the downloads from the site!
Highlights:
http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/interactions/Actions.html
) class.We’ve also deleted all methods that were deprecated in 2.0b3 and have marked a number of methods and classes (notably RenderedWebElement (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/RenderedWebElement.html
) and WebElement.getValue (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebElement.html#getValue()
)) deprecated. These will be deleted in the next release.
Known issues:
We plan on making our releases more frequent in the run up to 2.0final and polish off the bugs and issues. Stay tuned! This is going to be fun 🙂
We know that you have been waiting eagerly for this release and you have to wait no more. Selenium IDE 1.0.11 is now here and you can get it from the seleniumhq download site. The update will also be pushed to you automatically over the next couple days.
Other things of note around this release
•Release Notes
•Where to log bugs
•Welcome Selenium IDE 1.0.11 (with Firefox 4 support)
Half a century!
And because I am late doing this, the Selenium Test Day for Addons.Mozilla.org — which is today! gets top billing. Its actually going on Right Now. Looking to practice script writing and/or up your profile? This is a great way.
And now for the usual stuff.
Here is the next 10 links as I play catch-up.
It’s catch-up time again! Here is the first 10.
Nothing says ‘Hello Monday!’ like a batch of links and a wife with a kidney stone.
Let’s put Selenium IDE on Firefox 4 is Available for Testing! Now! outside of the normal list. We have a ‘working’ version of Se-IDE for FF4, but don’t really have too too much faith in it (or at least I don’t). Please help test it.
A Smattering of Selenium #45
So of course by now everyone has seen Selenium 2.0b3: The Next Gen Browser Release and upgraded their rigs. Expect Selenium IDE at some point in the next week with support for FF4 — if you just. can’t. wait. then you could try the bleeding edge for yourself. Logging any bugs you find; of course.
Oh, and there is the whole Selenium Conference next week.
But aside from that, here are the things I have collected.
It’s been about 5 weeks since the release of beta 2, so we’re very pleased to announce that Selenium 2.0b3 has just been released simultaneously for Java, .Net, Ruby and Python. You can download it from Selenium HQ or from the Google Code site. This release focused on providing excellent support for the next generation of browsers, particularly IE 9 and Firefox 4, and we think you’ll like what you’ll find.
http://selenium.googlecode.com/files/android-server-2.0b3.apk
)As well as these changes, there’s also the regular clutch of bug fixes and tweaks. For the number crunchers, there were a total of 331 changes that landed in the 5 weeks since the last release, with the 5 most active contributors working on each of the different languages supported by Selenium.
In addition to the enormous thanks that go to the developers, I’d like to add a big thank you to the Mozilla engineers who chipped in on the IRC channel at the last minute to help us work through some issues with Core. We’d not have been able to get this release out when we did without their help. Thank you Mozilla!
The next release will be focused on stabilization work, reducing our bug count and adding support for Grid 2.0.
What started out as the week of Capybara rounded itself out fairly nicely
I’m not a fan of using 3rd party abstraction layers (1st party are full win though) but Capybara has a large marketshare so Capybara (and Selenium) with RSpec & Rails 3: quick tutorial is likely going to be of interest to people.
And while on the subject of Capybara, here is a post on Checking Invisible Elements in it.
Keeping with the Capybara theme, we have Configuring User Agents with Capybara + Selenium Webdriver
Unit tests are overrated is a nice reminder to change all the tests in a system for a change — not just the unit ones. (C’mon, how many of us haven’t been burned and/or responsible for this.)
People-driven Test Automation includes this nice blurb
Successful test automation uses good tests that provide clear test results. A pass or no-pass result must be confident and trustworthy. By focusing on what the system should do rather than how it does it, this can be achieved easily and without breaking existing test cases whenever the logic of the system is changed.
Automate Kingdoms Camelot using Selenium reminds me of the days when I had the MUD we played in fully scripted.
How to include dynaTrace in your Selenium Tests is an interesting idea. Would be even better using Page Objects that were controlled externally so you don’t have to modify working scripts to enable/disable timings. But that’s an exercise for the reader to do. (Oh, and if their marketing firm wasn’t tweeting about it every day, that would be keen too.)
#SFSE Video: Selenium Problem Solving Sessions has, amung other things, a demo of the dynaTrace thing.
User-Extensions With Selenium RC Using Ruby Client Driver (selenium-client) is slightly out of date (use selenium-webdriver, not selenium-client) but aside from that, has an important missing bit of the user-extension documentation — how to use them from inside a script.
I haven’t watched it, but From Continuous Integration to DevOps: Co-Evolution of Agile and Automation seems interesting. I actually used the phrase “Selenium is the gateway drug to DevOps” the other week.
Jenkins, RVM, and Selenium is really about Cucumber, but…
Setting up Selenium server on a headless Jenkins CI build machine is similar to the 8th light one, but for Selenese
Selenium 2 with Firebug run on FF shows how to add an extension to a WebDriver profile. Now to write a script for all these plugins
Building Custom Test Frameworks is a bit of a cautionary tale
The whole where-is-this-binary-hiding-on-this-machine-problem on windows has bit people a number of times, Test Automation: Checking for Bit-ness suggests a solution (in C#)
Functional Tests with Selenium 2.0 and cargo-maven-plugin updates some common documentation around launching the Se server and tests from inside Maven
Is this week’s post the Answer to the Ultimate Question of Life, the Universe, and Everything Selenium?
We’ve just released Selenium 2.0b2. If you’re the impatient sort who loves to have the latest and greatest, head over to the download site and get it while it’s hot. If you’re a Python user, then all you need to do is a simple “pip install -U selenium”. Ruby users can, as ever, simply run “gem install selenium-webdriver”. Maven users need to wait just a little bit longer: we’re going to be checking the release in ASAP.
Between beta 1 and beta 2, we held a week-long Bug Bash, during which we closed a significant number of bugs. From a user’s perspective, other highlights include:
http://selenium.googlecode.com/svn/trunk/docs/api/java/com/thoughtworks/selenium/Selenium.html#getCssCount(java.lang.String)
) to mirror “Selenium.getXpathCount”http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebElement.html#getText()
) performs more consistently across different browsers.http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriverBackedSelenium.html
). If you’re looking to migrate from Selenium 1 to Selenium 2, and want to take your time, this is a useful stepping stone.If you’re interested in the guts of Selenium 2 and how it worked, then you might find these interesting:
As you can see, this is a big release. Beta 3 should be out a lot more quickly, and will be focusing on improving support for IE 9 and Firefox 4. Over the course of the 2.0b3 development, we shall also be removing as many deprecated methods as possible, so be sure to remove deprecation warnings from your builds when using 2.0b2!
There isn’t an official announcement anywhere (yet) but Selenium 2.0b2 was released a couple hours ago. Time to upgrade all your servers. Beta 3 is going to focus on IE9 and FF4 support.
Meanwhile…
I think the word that I’m looking for is “wow”. Perhaps “Wow!” would express the concept a little more clearly. Perhaps “WOW!” would be even clearer. Yes, definitely. “WOW!” is a good way of describing this.
Before Christmas, Opera Software announced a pre-release of OperaWatir, an implementation of the Watir 2 API. What you may not know is that Watir 2 rests on the same WebDriver core as Selenium 2. Today, Opera made the source of the OperaDriver available on github: https://github.com/operasoftware/operadriver
This is “WOW!” It’s the first time a browser manufacturer has released their own implementation of the WebDriver APIs, and it shows how much Opera values test automation. Selenium 2 users now have an easy way to test that their sites work with Opera.
What are you waiting for? Go! Download! Test!
You would think by now that I wouldn’t be surprised by the number of links I collect in a week.
It doesn’t seem that long ago that we announced on the mailing list that the Selenium project planned to join the Software Freedom Conservancy. I’m very pleased to announce that as of Friday, 21st January, our application was approved. We’re now under the aegis of the SFC.
From most people’s perspective, this won’t make much difference: you’ll still be able to view the documentation and download the latest versions of Selenium from Selenium HQ. Development will continue to use Google Code’s (http://selenium.googlecode.com/
) code hosting and issue tracking. We are now, however, part of a formal non-profit organization, which means that a number of issues, such as how to handle revenues from adverts on our sites, become clearer and more transparent.
There are more details about what this means in the SFC’s announcement and their list of membership benefits. The bottom line is that this is a major milestone in Selenium’s growth and ensures that as we continue to grow our user base and introduce new features and projects, we’ll have strong support and backing from a well-respected Open Source organization.
Hey look! All caught up — only took a month…
What a week! I’m almost (almost!) sorry that the Bug Bash is over. I’d like to say thank you to everyone involved in the Bug Bash, from those reporting issues, through those brave souls (Dharani, Anthony, Jari!) who went through the issue tracker, applied labels and made sure the issues were still fresh, all the way to those contributing fixes. And the top five bug fixers were?
Some interesting nuggets of information:
What does this mean? It means that the next release of Selenium is set to be very solid. We’re going to be spending another week or so making sure that everything is stable after the influx of changes, but you can expect 2.0b2 to be out “real soon now”
If you missed the Bug Bash but still want to contribute, it’s never too late. Feel free to drop by the IRC channel, or checkout the source, find a bug and start building!
If you’re using Maven and the 2.0b1 release of Selenium, you may be running into some problems getting maven to pick up your tests. The underlying problem is that selenium contains support classes for both JUnit and TestNG. The solution is to add this to your pom.xml
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium</artifactId>
<version>2.0b1</version>
<exclusions>
<exclusion>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
</exclusion>
</exclusions>
</dependency>
Will today be the day I finish three weeks of catch-up? Well, no..
UI Tests – putting it all together summarizes the series of posts using Watir and Cucumber, but the ideas could be converted to Se pretty easily.
I haven’t read it, but Essential Software Testdesign is now available for free [legitimately] as a pdf. Test Design is something I expect to see more discussion around in 2011 when it comes to Se automation. The rules really are different here.
Missed GTAC 2011 but want to be there vicariously? Now you can! GTAC #5: videos, slides, abstracts
Removing -htmlSuite from the Selenium Server and replacing it with a ‘real’ runner is something I’ve been thinking about recently after seeing [PROPOSAL] Webdriver Selenese HTML Runner. Who else has done this? Let’s see/share the code.
I was babbling on about Page Objects on Twitter and was sent a video on ‘BDD, ATDD and Page Object’. Haven’t had time to see it yet, but you might.
John Ferguson Smart from Mohinder Khosla on Vimeo.
Selenium Zoetrope is a PHP Se runner that will also record a video of your script’s run.
The Economist: Testing Drupal using Selenium is an experience report about the project that zoetrope originated in.
The elements of (cucumber) style is a nice ‘style guide’ you could consider adopting for your Cucumber scripts.
Another Selenium Auto Accept Self Signed SSL Certificates and Basic Authentication post, but this time with a Ruby bias for those who insist on having SSL turned on in environments other than production. (WHY?)
And from the same person, Testing PDF files with (and without) Selenium which is outstandingly cool. I know of at least one client who needed this a year ago.
No. Really. I’m almost caught up.
When the Selenium (http://selenium.googlecode.com/
) and WebDriver projects merged, all those moons ago, we moved the infrastructure from something we hosted to Google Code. One reason for doing this was to make it easier for people to file bugs and feature requests. And it looks like people have been filing a lot of bugs and feature requests.
In the run up for the 2.0b2 release, we’ll be running a Bug Bash. This will run from the 24th January all the way to the end of the 30th January. The aim will be to focus on clearing our bug list as much as possible, so that beta2 will be the best release of Selenium yet. We will, of course, be recognizing people who squash the most bugs here on the blog, and we’re hunting out goodies to mail to the top bug bashers once the week is over.
If you’d like to get involved, it’s easy:
That’s it. Easy! For help, and to ask questions of the core development team, please hop on to the IRC channel or email the selenium-developers group.
Update: The Bug Bash is now complete. All we have to do is count up the scores!
Let’s see how many announcements there were that didn’t get pushed out in a timely manner today shall we?
More tomorrow as we dig ourselves out of the hole.
My scheme for catching up with links last week ran afoul of 900 geeks and their families melting the internets at CodeMash 2.0.1.1. So let’s try it again this week.
And assuming I remembered to pay the internet bill, there will be more links tomorrow.
It has been mentioned at and hinted upon a couple times in the Smattering posts, but nothing has ‘officially’ been mentioned here, so it is time we fix that.
The first Selenium Conf is a go!
The logistics are set and we’re starting to sort out the program. Here is what you need to know. Right. Now.
This is a community driven event, though our friends at Sauce Labs are doing a lot of the leg work on the facilities (and food!), as so we want the community to be at the front of the room and not just the usual folks that do the talking circuit. (Unless you really want me to talk all day — which I can as many can attest.) Because of this we have extended the talk submission to Friday, January 21, 2011 11:59 PM (Pacific Standard Time) to expand the both the number of proposals and the number of people proposing talks.
Have a vague notion that you would like to submit something but not sure what we are looking for? I offer these as guide posts to help your thinking:
So again, submit your talk – or risk hearing me all day.
Oh, and mark on your calendars Tuesday, February 1 — because we bumped at the proposal date so too is the ticket release date.
Second in a week-long series of catch-up posts. But before I get to the next batch of links, don’t forget to submit your proposals to speak at the first Selenium Conference. I’m pretty sure we’re going to be trying to pick out the talks next week.
And now I’m off to drive through lake effect snow to get to CodeMash to stress out about my Selenium and Agile Testing workshops. Ah, the life of a consultant is certainly glamorous.
I have drastically fallen behind on the link reporting, but not the collecting, so this week’s Smattering will be multi-part.
The ‘big’ news falls for this edition is two fold –
And not to downplay things, but here are the usual assortment of things I think are of interest/value to those automating stuff [with Selenium].
Only 46 more links to go through… 🙂
We recently released the first of the betas for Selenium 2. It’s available for Java, C# and Ruby. If you’ve been holding off trying Selenium 2 because of the alpha label, then the biggest improvement you’ll see is with the new WebDriver APIs, but there’s a lot more!
http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.TargetLocator.html#alert()
).http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriverBackedSelenium.html
) when using webdriverhttp://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/SeleneseCommandExecutor.html
).http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/interactions/package-frame.html
) APIOf course, we’d love this release to be completely bug free, but this is, after all, a beta, so there are some known issues:
You can download it from here:
http://code.google.com/p/selenium/downloads/list
You can read the javadocs (http://selenium.googlecode.com/svn/trunk/docs/api/java/index.html
) and the ruby docs (http://selenium.googlecode.com/svn/trunk/docs/api/rb/index.html
).
An obvious question is “When will the beta end?” The short answer is when we’ve implemented the alerts and prompts and advanced user interactions APIs in all supported browsers. We expect there to be some flex in some APIs (removing deprecated methods, and within the advanced user interactions API) but what you have here is basically what you’re going to get when we hit 2.0 final. I have no idea how long this will take, but if you’re interested in helping out, let us know!
Thanks are due to all the committers who have worked so hard to get this code into shape. Thanks are also due to all the people who have taken the time to file bugs, ask for features and participated on the mailing lists. Thank you to you too, for going out and trying this new beta of Selenium 2.
You rock. 🙂
As mentioned in Simon’s Going Atomic: Why? and Going Atomic: How, part of the merging of Selenium and WebDriver is to share common code between the two. And as of the 1.0.10 release of Selenium IDE, this merged code, ‘atoms’ is now included.
Some early users of this release are noticing that this the atom that drives assertAttribute and verifyAttribute is causing their scripts to break. This post explains the ‘why’ and suggests how to fix them as well.
The HTML spec has the notion of a boolean attribute which is one that does something just by being there rather than by its value; checked and selected are two such examples of this. Optionally, you could give these boolean attributes a value that is the same as their name (checked=”checked”) and your page would still validate, but really, the browsers only care that the attribute exist.
Prior to 1.0.10, it was not uncommon for people to do something like
assertAttribute | checkbox@checked | checked
which fetches the value of the checked attribute on the checkbox with the id or name of checkbox and fails the script is the value is not checked.
In 1.0.10 though, that will fail even if it is checked. This is because checked is a boolean attribute and will now return either true or throw an exception saying the attribute doesn’t exist. Redoing the above step check that the boolean attribute is set results in:
assertAttribute | checkbox@checked | true
Thankfully, most of the real-world interaction with boolean attributes is focused on checked, disabled, hidden and selected and in these cases using assertAttribute is not really the right thing to do. Instead, the Selenium API provides wrappers for you to use.
checked | assertChecked(locator), assertNotChecked(locator), verifyChecked(locator), verifyNotChecked(locator) |
disabled | assertEditable(locator), assertNotEditable(locator), verifyEditable(locator), verifyNotEditable(locator) |
hidden | assertVisible(locator), assertNotVisible(locator), verifyVisible(locator), verifyNotVisible(locator) |
selected | assertSelected*(locator, pattern), assertNotSelected*(locator, pattern), verifySelected*(locator, pattern), verifyNotSelected*(locator, pattern) |
Checking for the absence of a boolean attribute that doesn’t have a nice wrapper is a bit of a pain though. In this example I am checking that the boolean attribute multiple is not on the select element with the name elephants.
assertEval | this.browserbot.findElement("css=select[name=elephants]").getAttribute("multiple"); | null
If you find yourself doing this very often, I suggest you wrap it up in a user-extension inside a plugin as something like
assertBooleanAttribute | css=select[name=elephants]@multiple | false
assertBooleanAttribute | css=select[name=elephants]@multiple | true
Hopefully this addresses some of the eventual ‘why the heck did my script break!?!?!’ problems that will no double crop up once Selenium IDE 1.0.10 gets wider distribution.
(If I wasn’t still recovering from a cold there would be something witty here.)
Great news! Thanks to the initiative of our friends at Sauce Labs, we’re finally ready to host the first-ever Selenium Conference. We’re still working out a lot of the details, but so far we’ve decided this first conference will be sometime in April and hosted in San Francisco.
In order to figure out the rest of the details, we’re looking for feedback from the Selenium user community. Please take a moment to fill out the following survey. Your answers will help us properly plan the best possible conference.
Thanks!
We’ll start this week with the official announcement of ‘Selenium 1.0 Testing Tools: Beginner’s Guide’ being available. Congrats David! (Still waiting for my copy…)
Oh. and I just noticed that this is the Selenium-iversay edition of these things.
…and here’s the links!
For those people paying attention to the goings-on in the Selenium world, yes, I am skipping something major until some of the details are worked out and announced. Until then, here are the links I accrued over the week.
The big news for last week was that I released Se-IDE 1.0.8 to very little fanfare. 1.0.9 should be a week or two and much more important a release.
I’ve missed a couple weeks due to travel and a complete system lock which meant I lost all the links I had open but not saved. So these are the ones I have recovered.
Oh, and both 2.0a6 and 2.0a7 have been released. We’re getting closer to the ‘API freeze’ which will mark the end of ‘alpha’ and the start of bug fixing (beta) for the final release.
We are extremely pleased to announce the release of Selenium 2.0a6! Head over to the downloads page to get it while it’s hot, or wait just a little bit longer for it to appear in a maven repo near you. The .Net version will also be updated soon too, and the python and ruby libraries have been having smaller, more frequent releases all this time.
You’ll be pleased to hear that the Selenium 1.0 APIs have remained constant, so what’s changed? Here, in no particular order are the major changes you’ll find in 2.0a6:
http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/html5/package-summary.html
) (best implemented, for now, by the mobile webdrivers)There are also lots of nice touches for the more technically inclined, including the ability to re-use instances of FirefoxProfiles (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/firefox/FirefoxProfile.html
), better configurability when requesting a remote webdriver instance, better resource management and more shared code between the Selenium and WebDriver implementations.
Thank you to everyone who has taken the time to report a bug on our issue tracker, or raised problems on one of our mailing lists, or shown up for some of the banter on the IRC channel: without your involvement, the project wouldn’t be half as much fun, and wouldn’t be as capable as it is. Thanks are also due to the development team, who have poured an enormous amount of work into this release (538 revisions in under 90 days, or about 6 check-ins each and every day)
Hope you like it!
A fair number of links this week. The vast majority of which were buried in annoying airport internet advertising frames…
So we go from not-enough-stuff-to-do-one to wow-this-will-take-awhile. And we’re off..
Seems I skipped a week, but that’s okay since there hasn’t been much in terms of volume (or maybe my clever search filter is a bit overly clever…).
It’s Labour Day here, so this post was written to backdrop of Sponge Bob. In case you were wondering.
This is the second of my technical posts. Again, if you’re interested in the internal workings of Selenium 2, then please skip straight to something else. If you’re interested in how and why we made some of the technical decisions on the project, keep reading….
We left our intrepid heroes in a tight spot: they’d decided to write a shared library of code, to be used by the various webdriver implementations and selenium core, but the requirements for doing this seemed to be at odds with it actually happening.
Fortunately, at about the same time we started down this path, Google Open Sourced the Closure compiler. This is a Javascript compiler that takes as input a set of Javascript files, and which outputs Javascript. It can be configured to either pass the code through untouched into a single file, or it can compile a script aggressively, removing unused code-paths and minifying the output as much as possible. The Closure compiler is used on a lot of Google products, so we know that it’s reliable and consistent.
In order to get the best out of the Closure compiler, we’re writing the atoms using the Closure library. This isn’t as well known as some of the other JS libraries out there, but it’s solid, well tested and is being actively developed. It also features an easy-to-use extension of JsUnit, which makes writing tests a far simpler task than might otherwise be the case, and it has an easy to use mechanism for modularizing code.
So, given that we could compile a single Javascript function (and it’s dependencies) into a minified fragment of JS, we were all set, right? Not quite.
The problem is that the atoms are being extracted from two frameworks that have a different way of viewing the world. As an example, Selenium 1’s getAttribute (http://selenium.googlecode.com/svn/trunk/docs/api/java/com/thoughtworks/selenium/Selenium.html#getAttribute(java.lang.String)
) method only returns the value of a particular attribute, whereas WebDriver’s getAttribute (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebElement.html#getAttribute(java.lang.String
)) method will return the value of either a property or an attribute (because sometimes it’s hard to remember whether something is an attribute or a property of an element)
As with all problems in computer science, an extra level of indirection is used to solve this issue.
We’re busy implementing the expected behaviour of both WebDriver’s and Selenium’s API on top of the atoms.
There is, of course, the obvious question about how we get this carefully compressed JS into a driver. One option would be to include the raw Javascript as files in each language binding, and pull them in as required. That’s possible, but it would make each language binding bloated, and would introduce a lot of duplication. The alternative is to push the atoms as far into the driver as possible, and this is what we do. As part of the build process for webdriver, we take the compressed JS and convert it into a form that can be consumed by a particular driver. For example, for the IE driver, we convert them into constants in a C header file. These constants can then be referred to by the driver and converted back into a script than be executed via the same mechanism that is used by “executeScript”.
What do we gain from this seemingly baroque approach? Other than the ability to share the same code between drivers? Many things. The cost of maintenance drops dramatically as we can fix a bug in one place and have that fix be picked up by every driver. Because we’re working in pure JS and just querying the DOM, we can run the unit tests in a browser whilst we’re developing the code. This leads to a very tight feedback cycle. It also makes it easier for developers not familiar with the code to take a look at how we do things, and send us patches (always appreciated!) Finally, we can ensure a consistency of result.
Right, any questions?
A day late, but that sort of thing happens when you have family.
A bit late, but I’m in California for a Selenium Developers Meetup and my body doesn’t quite know where it is temporally.
I was at Agile 2010 in Orlando last week so missed doing the Smattering, so here is two weeks worth of links.
This is the first in a series of technical posts by me about the internals of Selenium WebDriver. If you’re not interested in technical nitty-gritty, then feel free to step away now.
Still here? Excellent.
Let’s take a step back to just before the Selenium and WebDriver projects merged. There were, very obviously, two separate codebases. Looking closer and with a slightly different perspective, there were more than this. We used the test suites for webdriver to define the behaviour for multiple, largely independent, driver codebases. The IE driver was written in C, the HtmlUnit driver in Java and the Firefox driver is largely Javascript, and so on.
This means that there was a lot of “congruent code”: code that performed the same function but was implemented in a different way. The natural result of this was there was the possibility for behaviour to diverge between drivers. Worse, it meant that when a bug was found, we had to check it in every browser, and it wasn’t certain that an individual could actually fix the code. After all, not everyone is comfortable writing in all the languages we use on the project, or is au fait with all the technologies. For an Open Source project like Selenium, this is a major problem: we rely on a relatively small core of key developers backed up with a far larger team of individuals submitting small changes and fixes. Anything that makes it harder for us to function effectively as a development community is a Bad Thing.
So, we wanted a way off the island; a mechanism that would make it easy to share code between the various drivers and selenium core, that allowed us to fix a bug in one place only and have that fix ripple out to every driver that made use of this mechanism. More importantly, it had to be easy to use, and for someone not familiar with a raft of languages and technologies to quickly get started with.
What would this mechanism look like? Well, there’s a few things that feed into this, but the most important one, was that a majority of the code we’d think of merging was querying the state of the browser (“find an element”, “get the value of this attribute”) and, as Jason Huggins would point out to me at the drop of a hat, the natural language for querying the state of a browser is Javascript. One of the nice things with Javascript is that it’s possible to get a nice, fast development cycle going in it. Just modify a test, save and then hit “refresh” in the browser. That’s kind of attractive. Better still, there are a lot of developers familiar with Javascript.
So, we decided to use Javascript.
Because this shared code was to be composed of the smallest useful fragments of functionality required for browser automation we decided to refer to them as “Browser Automation Atoms”, or “atoms” for short. Rather than write them from scratch, the easiest thing to do was to extract them from the existing code — this is stuff that’s been battle-tested, so we know it’s robust.
There was one very obvious fly in the ointment: not every driver is written in Javascript. Although we have a mechanism available (http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/JavascriptExecutor.html
) in every browser for executing JS, it’s wildly inefficient to dump an enormous lump of code on to the JS engine of the browser whenever you want to query the DOM. After all, most of the code would not be needed, and not all JS engines have been created equal. Some are blazingly fast. Others, not so much.
It would also be nice to break the code up into manageably-sized modules, rather than being in a single, monolithic file, which implies some clever “module loading” capability. Except this code isn’t always going to be executing inside an environment where writing “script” tags to load additional scripts is possible. You can’t do that in the guts of a firefox extension, though you can load files other ways. However we tie modules together will need to cope with that.
Ah! These opposing requirements: small modules containing the functions we want to use, no extraneous code, and for everything to be in a single file in order to minimize the pain of loading additional modules. That doesn’t sound like a very compatible list. How we resolved those differences is the topic of my next post….
The Selenium project does not have an ‘official’ presence here at Agile as it is seen as a ‘test after’ tool rather than ‘test first’ — even though it provides the magic of the ‘test first’ frameworks… But there is a small, unofficial contingent of recognizable faces around that can help people out and some sessions on it.
Sessions
Why your selenium tests are so dang brittle, and what to do about it – Wednesday, August 11 – 3:30 – 5:00
If you are writing automated through-the-GUI tests for a web application, you are in danger of creating tests that are more expensive to maintain than they are worth. With well-factored Selenium RC tests running in Junit or TestNG, you can keep your abstraction layers or “Lingos” — small bounded bits of slang for discrete parts of the object model — separate, thereby reducing the maintenance costs of your tests, and improving your sanity. Prerequisites include experience with Java or C#, and ideally some *basic* OOD familiarity (inheritance, composition, encapsulation, polymorphism).
Selenium Open Jam – Tuesday, August 10 – 11 – 12
Bring your questions or problems or complaints. We’ll try to ease / solve them.
People
If you are not succeeding with Selenium, come track down one of us. We might redirect you somewhere else, but eventually we’ll get you sorted out.
The GSoC 2010, it’s a great adventure.
I’m Raynatou, I come from Burkina and do my internship at SERLI. Like all interns in this company the topic of my internship focuses on advanced topics like the integration of WebDriver as backend for Selenium IDE. Selenium IDE is currently built upon Selenium Core for interacting with web pages. Selenium Core has several major limitations, including the inability to fire native events. To avoid these limitations and produce more robust tests, I am investigating Selenium IDE to using WebDriver in place of Selenium Core.
I’m mentored by Eric Allen from SauceLabs, my lead mentor, and by Jérémy Hérault from SERLI, his second but not least ;).
Eric has already done most of this integration earlier this year. The goal of his work is mostly to show what’s possible with Selenium IDE and the Selenium 2.0 Firefox driver. It is based on an asynchronous communication between the Firefox WebDriver extension and Selenium IDE, Se-IDE waiting for that WebDriver says to him that the current command has been passed with success (or not) to call the next command of the current test case (use of callback function). The goal of my mission is to finalize this integration. However, Eric being a crazy man, and he has done it quickly and together we though to another way to do this merge.
Our new thinking is based on a synchronous communication between both of them. To do it, I get the FirefoxDriver instance and play with it like a normal object, by calling its methods. But the behaviour of FirefoxDriver isn’t as simple as I was thinking. JavaScript being a powerfull language (yes, it can make you shiver), I’ve had just to replace some objects (like Response object) and to use a Proxy (and a bit of IoC-like code) to simplify my life and the code to do. You can see my work on GitHub and follow it.
Currently, I think that more than 95% of the Selenium API commands are usable with WebDriver as backend in Selenium IDE. The process was basically to go through the seleniumemulation package and port all of the Java classes into JavaScript methods on the WebDriver class.
Now, I’m working on Unit tests to cover any of the 2.0 work I’ve done. I managed to get all of the Selenium Core tests to run through IDE. I’ve some refactorings to do to optimize the code and add more comments for a bigger comprehension of my work. I have almost finished.
I hope you enjoy what I’m doing and we hope (me and my mentors) that this work can be included in the wave of Selenium 2.
Happy Simcoe Day. Only a handful of links this week to mention.
There are several ways to use Selenium 2:
Whichever option you prefer, if you have want to use Maven, all you need to do is add the following dependency to your pom.xml:
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium</artifactId>
<version>2.0a5</version>
</dependency>
If you know, that you will only use a certain WebDriver implementation, e.g. the FirefoxDriver, you don’t need to depend on the selenium artifact (which has dependencies to all WebDriver implementations as well as the support classes). Instead you can add the dependency to just the artifact you need, e.g.
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-firefox-driver</artifactId>
<version>2.0a5</version>
</dependency>
When using a WebDriver implementation, there is no need to start a Selenium server – the browser will be directly started and remote controlled.
But if you are using DefaultSelenium (or the RemoteWebDriver implementation), you still need to start a Selenium server.
The best way is to download the standalone Selenium server jar and just use it.
Furthermore you can also embed the Selenium server into your own project, if you add the following dependency to your pom.xml:
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-server</artifactId>
<version>2.0a5</version>
</dependency>
Now you can create a SeleniumServer instance yourself and start it.
Be aware, that the selenium-server artifact has a dependency to the servlet-api-2.5 artifact, which you need to exclude, if your project will be run in a web application container.
Well, I hope that covers everything you need to know on how to use Selenium 2 with Maven.
Michael
I thought it had been a slow week — until I looked at how many browser windows I had open. I wonder if that was why things were feeling a bit sluggish…
Some bits of history from Simon Stewart
More history lessons on Cloud Computing Show #35 where Jason recounts the origin of Se (and other stuff)
I still maintain that Continuous Deployment to production is near unethical, but a lot of the tricks that companies are using to support it are pretty cool. Continuous Deployment, Code Review and Pre-Tested Commits on Digg4 details some that Digg uses. Only cursory mention of Se, but once you have Se running inside a CI server of some sort, these thoughts become interesting-er.
The Kitchen Sink – why not all tests need automating has things like Just because we can automate a test doesn’t mean that we always should. As a consultant, I need to get this point across to clients all the time. Every. Single. Day.
At the risk of being too meta, there is now Selendion which looks like it drives Concordian with Se
Frank is billing itself as ‘Selenium for iOS’. Except that I believe Se2 already has support for that.
Moving on to the second example is part of a series of posts about exploration of Se2 using Ruby. This particular post is the ruby-fication of the second example of the WebDriver tutorial.
Debugging XPath and CSS locators with Selenium IDE originated with a question on the RobotFramework-Users mailing list and ended up being a screencast. We should do more of those.
Boomerang seems like a project that someone should write a tutorial on integrating with Se
Review: TDD Screencasts is a review of Kent Beck’s new TDD Screencast series (I really should buy this). While yes, we typically don’t do TDD using Se for speed reasons, this paragraph resonated and since I do the list, I’m including it.
A great message I got from the screencasts is that your tests should tell a story. You compose that narrative in steps, so as to not trip yourself up. Many times you are probably required to develop against a backend service or directly with a database. So that’s how the story starts. Hello Mr. Database, are you there? May I put something in you?
If you are a PHP developer and using NetBeans, then Testing with PHPUnit and Selenium might be of interest.
Integrating Selenium Tests into CruiseControl.Net via NUnit is what it claims
Avoiding Brittle Element Selection with Selenium2 tackles a constant topic using Se2 — but it can be applied to Se1 as well
In the beginning there was Se1, and it was good. But it could have been better — in ways that WebDriver was starting to be good at. Thus the brilliant idea was hatched to merge the two projects.
And then the confusion began. Let’s see if I can start to address some of it via a ficticious conversation that consolidates the Se-user list and #selenium irc channel.
There are a couple annoying bugs in Se-RC 1.03; when is the 1.0.4 release?
Se-RC 1.0.4 is planned for sometime towards the end of July 2010
I’ve heard rumours that 1.0.4 the to be the final release?
Yes. 1.0.4 is planned on being the final 1.x release
That’s crazy talk! I can’t use a .0 or ‘alpha’ release for my mission critical application
Actually, its not all that crazy — and needs a bit more explanation. Se2 is truly a merger of the two projects, in fact 2.0a1 was literally the Se code from the OpenQA repository and the WebDriver code its Google Code repository merged into a new one. This meant that from the first release of the 2.x series, it has contained 100% of the 1.x code which means 100% backwards compatibility. Later releases in the 2.x series have been driven primarily by evolutions of the code that came from WebDriver, not from Se 1.x.
OK, so 100% of Se 1.x is in 2.x; I get that. But how are you making sure that fixes to one get into the other?
Here is another ‘secret’ — don’t tell anyone, but there hasn’t been any pure 1.x development since the merging of the codebases. Every 1.x release since the merger has really been a 2.x release — but all packaged up to make it look like a 1.x release. This is why observant people have noticed a log message that looks something like 11:09:37.507 INFO – v2.0 [a4], with Core v2.0 [a4] when they start up their 1.x server.
So you’ve been releasing alpha code disguised as a stable release? Jerks!
Woah! Relax! Recall what I said above about it being backwards compatible by default. The ‘alpha’ tag is there because the API for the new code is still being developed and features flushed out. The 1.x code is however, still stable and still production quality.
Alright, I take back calling you folks jerks, but I really don’t like the alpha tag. When will it be out of ‘alpha’?
There is only one or two more features to implement (like handling alerts) in the WebDriver code and some cleanup before the betas start. But hope for a 2.0.0 final by the end of the year. And while we’re on the topic of ‘alpha’ vs. ‘beta’, this the team’s working definitions of each.
‘Major Browsers’ eh, what exactly does that mean?
Right now it means Firefox, Internet Explorer and at least one WebKit based one (Safari or Chrome)
In short… it is a requirement of Se2 that the server be backwards compatible with Se-RC 1.x and that has already been accomplished by building the code from a common source repository. This means that if you are using Se-RC, you can switch out the server for a 2.x one and have no impact on the execution of the scripts. Plus you can start to experiment with the new stuff that came over from WebDriver.
12 hours late, but I was driving draft horses all day so that’s my excuse and I’m sticking with it. Enjoy. I’m going for a nap.
What’s new for Selenium this summer ? The GSoC of course !!!!
I’m Jérémy, a french engineer and I work at SERLI, a services company based in France.
I’m working on Selenium since a year and this summer I’m mentoring Aleksejs for the GSoC 2010. I’m helped by David Burns when I’m on vacation or offline. His experience is really useful to me, and David is involved on student supervising regularly.
Aleksejs comes from Latvia in Europe (yes I know you know but perhaps Geography wasn’t your favorite subject at school ;)). His work was initiated by Patrick and myself. We thought to a remote system that allows Selenium users to save and get remote test cases, directly with Selenium, without any other installations like SVN.
What’s better than record a test case with Selenium IDE and save it on your remote storage? what’s better than share your test cases with colleagues without any other installations, just by using Selenium IDE or a Selenium Remote Storage client?
For myself I don’t know what’s better 🙂
Aleksejs has already coded the server side of the remote storage mechanism with all the necessary unit tests. He has also created a web interface to use it directly through the browser. With his work, you can put, get and delete a test case, and you can also browse the directory where test cases are stored. His work has been done in Java, and he used JSON, for data representation for the communication protocol. This system is really simply to use, based on REST technology, you only have to call URLs with the good parameters.
The next step of his work is to create a Se-IDE plugin based on the API done by Adam (thanks to him). This part has to be done in less than a month and I think it’s a hard task, but it’s so cool to write your own plugin. In this case, Aleksejs will use JavaScript, AJAX and XUL technologies. It’s really good to learn a lot of technologies for its own culture, it’s so trainer.
I hope you’re enthousiastic to get this new feature, but wait until October, when the work will be finalized 🙂
Enjoy guys, Aleksejs, David and I are ready to discuss on it if you have any questions. And good luck with the end of this adventure Aleksejs.
I’m pleased to announce the release of Selenium 2.0a5, available for immediate download. This release brings a host of changes under the hood, and represents the efforts of many contributors. Highlights include:
http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/html5/package-frame.html
) for dealing with HTML 5 elements.http://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.Timeouts.html
): quietly waiting until an element is present before continuing with a test. You can use them like this: driver.manage().timeouts().implicitlyWait(15, TimeUnit.SECONDS)
Waiting in the wings for release soon is an AndroidDriver, which opens up the world of testing webapps on Android devices through the Selenium WebDriver API.
If you’re a pythonista or rubyist, you’ve not been left out of this bonaza of new hotness. There have been regular updates for these languages, which can be installed via “easy_install -U selenium” or “gem install selenium-webdriver” depending on your language of choice.
Hopefully the next alpha will be the last before we plunge bravely into the betas. Exciting times are ahead!
I’ve got a full day of driving ahead of me to go to a client so this is the early-morning (for me) edition of the Smattering post. That of course means there will be an absolute link explosion in about 20 minutes.
And lastly, BrowserMob, which was started by Se Core member Patrick Lightbody announced that it has been acquired by Neustar Webmetrics. Congrats! Now stop drinking the champagne and get back to work! 🙂
Its been around six months and three releases since I took the reins of Selenium-IDE. The fundamental change in that time has been the adoption of a plugin model like the fine folks over that Firebug. (We’re also self-hosting it which is big from a project internals perspective.)
Right now, you can add custom user-extensions and formatters, but in the very near future you will be able to add location strategies as well.
So what does the future look like for Se-IDE?
There is also work on reworking the internals of Se-IDE from a synchronous model to an asynchronous through Google Summer of Code. If that is successful and we decide to use it, that will trigger a bump to 1.1.0.
Timelines you ask? Well, when I took over Se-IDE the plan was to do it monthly. That was either naive or overly optimistic so they are starting to stretch a bit. 1.0.8 is going to stretch it some more too. Look for a beta of 1.0.8 towards the end of the month with a final version by mid-August.
I know you are likely wondering what cool, superdidooper features will you be seeing in Se-IDE over the next while? Ummm, well, actually none. At least not from the core Se-IDE. There will be significant pushback on any new ‘feature’ or change that adds something to Se-IDE. If you cannot accomplish your goal through a plugin, then I would consider than an omission in terms of the API.
Thats where we are from the maintainer perspective, but end-users also have sway over this as well to some degree. We’re now using the Google Code Issue Tracker for managing the project. If you bug is not there, there is a significantly smaller chance of it being addressed. And if an issue has a number of stars on it, that is also an indicator we should be looking at it.
Now to hack on locators…
Not too much this week with various holidays around the world, but still managed to dig some things up.
And lastly, the Selenium Stack Exchange proposal has progressed to the next level which is getting people to commit to using it. The number of commits is a convoluted formula, but every one counts. If you think the Se-Users mailing list is too crazy, this format might be better for you.
Here are the posts dealing with Se, and/or automation in general that caught my eye and interest.
I’m going to start posting the Smattering posts here on the main Selenium blog, hopefully each Monday. For past ones see my personal blog’s archive
We’re pleased to announce the release of Selenium Grid 1.0.8. This release fixes multithreaded issues with the Selenium Grid hub that appeared randomly under heavy load. If you’ve ever seen a log message about HttpClient being accessed by multiple threads, you definitely want to upgrade. Even if you haven’t, this release is highly recommended for all.
You can download it now or view the changelog. The list of changes is:
Many thanks go out to Chris Gulley for identifying and fixing the problem. As always, patches and bug reports are appreciated:
I mentioned in the release notes for 1.0.7 that barring any major issues, 1.1 would be the next release. This fix was major enough to warrant an intermediate release. We are still planning to put out 1.1 as the next feature release.
If you have any questions about Selenium Grid, please use either the user or the developer list, as is most appropriate for the nature of your question. Ongoing discussion about grid development should take place on the developer list.
So its a month later than planned, but Selenium IDE 1.0.7 is now available. The delay was due to some internal build changes and not code, but one of the code changes that is there more than makes up for the delay.
That’s right, drag-and-drop has finally arrived to Se-IDE — though credit lies with Jérémy Hérault for implementing it.
Oh, and if you are Swedish, there is now a localization for you. Yes, a real one. Not just one that makes everything say Bork as was suggested to me. Although a Pirate locale might be arrr-some.
For those with version 1.0.5 or newer, the update will be pushed to you automatically over the next couple days. Those new to Selenium IDE or with 1.0.4 or older will want to install it now.
Other things of note around this release
Following up on the Selenium Grid 1.0.6 release, which was mostly a bug fix release, we’re pleased to announce the release of Selenium Grid 1.0.7. This is another bug fix release that focuses primarily on how Selenium Grid handles browser sessions.
You can download it now or view the changelog. The list of changes are:
As always, patches and bug reports are appreciated:
Barring any critical issues, the next release of Selenium Grid will be 1.1 and will feature an enhanced Web view as well as a status API. After that, we will be moving from GitHub to Google Code to live alongside the other Selenium projects.
If you have any questions about Selenium Grid, please use either the user or the developer list, as is most appropriate for the nature of your question. Ongoing discussion about grid development should take place on the developer list.
As you likely know by now, after years of stewardship Philippe has stepped down as maintainer of Selenium Grid and has named me the new maintainer. In this post, I hope to address the most immediate questions about what this means for the future of Selenium Grid.
I realize many of you may not know who I am. I’ve been using Selenium in some capacity for close to five years now. I love working on open source software and do so primarily through my membership in the Apache Software Foundation and through my GitHub account. I hang out on the #selenium channel with the handle “nirvdrum” and have a personal page that includes some articles I’ve written and other things I’m involved with. Perhaps more importantly, I also rely on Selenium Grid for my latest start-up so I’m very keen on seeing the project mature and evolve.
The new canonical project repository on GitHub is the nirvdrum fork. However, within in the next month or so the project will be migrated from git and GitHub to subversion and the Selenium project on Google Code. As much as I personally prefer GitHub to Google Code, it makes the most sense from a community perspective for all Selenium projects to be hosted in the same location. The move will be made after Selenium Grid stabilizes a bit more. The 1.0.6 release was the first step in that process, but there may be one or two more minor patch releases. After the move, I’ll try to maintain a synchronized mirror of the code on GitHub so those that prefer to develop patches with git can continue to do so.
The canonical issue tracker is the Selenium issue tracker on Google Code. We will not be using either JIRA or GitHub Issues. I’ll try to migrate what I can over to the new tracker, but if I miss anything, please re-open the issue over there.
Selenium Grid currently only works with Selenium 1.x, and consequently the 1.x compatibility interface in Selenium 2. There is currently no support for WebDriver. However, I fully intend to steer the product in that direction, while maintaining support for existing Selenium Grid installations (i.e., based on Selenium 1.x).
Since the project is moving to Google Code, all of the existing Selenium committers will have the ability to commit to the codebase. This should make the project’s evolution a much more collaborative effort. I’ll kickstart the process and likely lead the development effort, but the role of maintainer will be diminished (in a positive way) by allowing the entire core team equal access to the project.
Others are welcome to chime as well. Selenium Grid development discussion will be taking place on the Selenium developers list. Please continue to use the Selenium users list for usage and support inquiries.
Selenium 2.0a3 has been released and can be downloaded from the Selenium project site. This is a major update to 2.0 and all users are encouraged to update. The new features include:
The .Net, Python and Ruby bindings will be updated soon, as will the maven artefacts.
The next release will be Selenium 2.0a4, and it is planned to include the following when it is released in late May:
Following up on the Selenium Grid 1.0.5 release, which added self-healing features to ease grid management, we’re pleased to announce the release of Selenium Grid 1.0.6. This is a bug fix release for 1.0.5 with some minor new additions.
You can download it now or view the changelog. The summary of changes are:
In case you missed the announcement, Philippe is no longer maintaining Selenium Grid. We thank him for his years of effort and helping the project get to where it is today. This is my first release as the new Selenium Grid maintainer. I will be getting out a new post shortly that lays out the future for the project [UPDATE: The promised post is live]. In the meanwhile, please note the new location of several key resources:
If you have any questions about Selenium Grid, please use either the user or the developer list, as is most appropriate for the nature of your question. Ongoing discussion about grid development should take place on the developer list. We look forward to hearing what you think about how we can improve the project.
Hot off the heals of 1.0.2,
we’re releasing Selenium Remote Control 1.0.3. You can download it now (http://selenium.googlecode.com/files/selenium-remote-control-1.0.3.zip
).
There is no functional difference between this version and 1.0.2, other than it is packaged up a little nicer and we’ve clarified the relationship between selenium-server and the client drivers. That is: we are not releasing new client drivers with future 1.x releases. The reason is that we locked down the API in version 1.0.1 and so there is no need to push out the same code each time. As such, when you download 1.0.3, you’ll see all the client drivers are labeled version 1.0.1, which is expected.
This release also is zipped up in a way that is compatible with all operating systems. The 1.0.2 release had some reported issues on Windows that have been fixed.
Finally, we also had many requests from Maven users. While we no longer use Maven to build Selenium, we are including pom releases for both the standalone server (ie: selenium-server.jar) and the “coreless” server (ie: selenium-server-coreless.jar). We hope they will be in the central repository shortly.
Today we’re happy to announce that Selenium Remote Control 1.0.2 has been released. While most of our efforts are on Selenium 2.0, we understand that there are millions of Selenium users that still need the 1.x line supported. That’s why we’ve said from the start that our goal is make 2.x 100% backwards compatible with 1.x. And that’s why we’re releasing a new version of Selenium RC today.
Download it here (http://selenium.googlecode.com/files/selenium-remote-control-1.0.2.zip
).
In addition to many bug fixes, the biggest improvements in this version are support for both Firefox 3.6 and OS X Snow Leopard.
Since we moved away from Clearspace for our forums, it’s time we also did the same for our blogging platform. As such, the new location for the official Selenium blog will now be:
http://seleniumhq.wordpress.com
We hope to be much better about posting news, tips, and tricks here going forward.
Learn more or view the full list of sponsors.