Selenium – beta

Blog: Selenium 4 Beta 1 Released

Mon, 15 Feb 2021 00:00:00 +0000

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:

Relative locators, for finding elements using terms that make sense to us humans.
The ability to intercept network traffic
Authentication with basic or digest authentication.

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.

Blog: Selenium 3 is Coming

Tue, 04 Oct 2016 00:00:00 +0000

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.

TL;DR:

WebDriver users will just find bug fixes and a drop-in replacement for 2.x.
Selenium Grid users will also find bug fixes and a simple update.
The WebDriver APIs are now the only APIs actively supported by the Selenium project.
The Selenium RC APIs have been moved to a “legacy” package.
The original code powering Selenium RC has been replaced with something backed by WebDriver, which is also contained in the “legacy” package.
By a quirk of timing, Mozilla have made changes to Firefox that mean that from Firefox 48 you must use their geckodriver to use that browser, regardless of whether you’re using Selenium 2 or 3.

In more depth:

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.

Blog: Announcing Selenium 3.0-beta1

Fri, 29 Jul 2016 00:00:00 +0000

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:

You’ll need to be running Java 8 to use the Java pieces of Selenium. This is the oldest version of Java officially supported by Oracle, so hopefully you’re using it already!
Support for Firefox is via Mozilla’s geckodriver.
Support for Safari is provided on macOS (Sierra or later) via Apple’s own safaridriver.
Support for Edge is provided by MS through their webdriver server.
Only versions 9 or above of IE are supported. Earlier versions may work, but are no longer supported as MS no longer supports them.

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.

Blog: Selenium 2.0rc3: The “Next One’s The Big One” Release

Mon, 27 Jun 2011 00:00:00 +0000

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:

The deprecated RenderedWebElement interface has now been removed. Most of the functionality has been moved to either WebElement or to the Actions class.
The deprecated WebElement.getValue() method has been removed. Use WebElement.getAttribute(“value”) instead.
After some debate in the team, “WebElement.setSelected” and “WebElement.toggle” have been deprecated. They will be removed in the final release.
Thanks to the hard work of Mozilla engineers, we now offer Firefox 5 support.
The Opera driver, developed by the lovely chaps at Opera Software, is bundled with this release.
Improvements in the way that mouse interactions are simulated, particularly when elements are outside the visible area of the page.

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.

Blog: Selenium 2.0rc2: The Better Working Release

Thu, 02 Jun 2011 00:00:00 +0000

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!

Blog: Selenium 2.0rc1: The Grid Release

Wed, 01 Jun 2011 00:00:00 +0000

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:

Grid 2: A major feature of this release is Grid 2, an implementation of the Selenium Grid that supports WebDriver’s wire protocol, allowing tests using Selenium WebDriver to be distributed through it. There are some docs to help you get started on the wiki.
New ChromeDriver: Following a complete rewrite of the ChromeDriver, Selenium 2 is now supported natively by the Chrome browser itself. In order to use this, you must download the chromedriver executable from the Selenium project site.
OperaDriver support: We’ve bundled the most excellent OperaDriver into the release to make it easy to get started testing with Opera.
Support for native events in Firefox 4.
Advanced User Interactions: An API that allows you to model complex user interactions, such as clicking on an element, holding the shift key, clicking on three more, and then dragging the four elements to a final destination. The entry point to this API is the Actions class.

We’ve also deleted all methods that were deprecated in 2.0b3 and have marked a number of methods and classes (notably RenderedWebElement and WebElement.getValue) deprecated. These will be deleted in the next release.

Known issues:

Native events on Linux may not work properly on tests that include alerts and prompts.
Mouse actions using the Advanced User Interactions API may not work properly for elements that have to be scrolled into view.

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 🙂

Blog: Selenium 2.0b3: The Next Gen Browser Release

Mon, 21 Mar 2011 00:00:00 +0000

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.

Restructured documentation at Selenium HQ
An improved user interaction API
- Including experimental IME support on Windows.
Alerts and prompts handling for IE.
Marked the following APIs as obsolete in .Net:
- IRenderedWebElement.Hover()
- IOptions.Speed
Even more improvements to the Java webdriver-backed selenium
- We’ll document the migration path before 2.0b4 is out!
A significantly faster Android Driver

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.

Blog: Selenium 2.0b2 Released

Tue, 15 Feb 2011 00:00:00 +0000

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:

A more stable, capable iPhone driver.
Updated Android driver.
Improved python bindings for Selenium WebDriver. The namespace is now “selenium.webdriver”
Added “Selenium.getCssCount” to mirror “Selenium.getXpathCount”
“WebElement.getText()” performs more consistently across different browsers.
Mono users can use the .Net bindings
Continued to improve the WebDriverBackedSelenium. If you’re looking to migrate from Selenium 1 to Selenium 2, and want to take your time, this is a useful stepping stone.
Reworked the Advanced User Interactions APIs. The big change is that the WebDriver APIs no longer rely on classes from the AWT.
.Net users now have more support classes, to make writing tests less tiresome.
The remote webdriver makes better use of sockets, which improves stability and scalability on Windows.
Started to add support for driving multiple IE instances. This is considered experimental, but we’d love to hear it’s working for you!

If you’re interested in the guts of Selenium 2 and how it worked, then you might find these interesting:

Continued reworking the IE and iPhone drivers to use the Automation Atoms.
Reworked the structure of the source tree to be more language focused.
We have the skeleton of a webdriver-backed selenium for Python.

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!

Blog: Selenium 2.0 beta 1 Release

Fri, 24 Dec 2010 00:00:00 +0000

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!

A promise of relatively stable APIs
For Firefox only right now, an API for dealing with alerts, prompts and confirms.
A brand new IE driver.
Better selenium emulation when using webdriver
And a better implementation of webdriver’s API backed by the traditional Selenium technology.
Ubiquitous use of Sizzle for emulating CSS selectors where native CSS selectors aren’t supported
The advanced user interactions API
An update to the AndroidDriver’s Android app.

Of course, we’d love this release to be completely bug free, but this is, after all, a beta, so there are some known issues:

The selenium 1.x emulation using IE is a little flaky.
The ChromeDriver is not as capable as the others.
Anything in our bug list.

You can download it from here:

http://code.google.com/p/selenium/downloads/list

You can read the javadocs and the ruby docs.

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. 🙂

Blog: Selenium 2.0a6 Released

Fri, 08 Oct 2010 00:00:00 +0000

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:

Android support: you can now download the APK and run webdriver tests using Android 1.6 to 2.2.
Firefox 4 support.
Experimental IE9 support
New APIs for dealing with HTML5 elements (best implemented, for now, by the mobile webdrivers)
A richer .Net API
A move to Sizzle for locating elements using CSS in browsers that don’t have a native API for that.
Far better support for running your existing Selenium RC tests using WebDriver, helping you make a managed migration to the newer APIs.

There are also lots of nice touches for the more technically inclined, including the ability to re-use instances of FirefoxProfiles, 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!

Blog: Selenium 2.0a5 Released

Wed, 14 Jul 2010 00:00:00 +0000

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:

New interfaces for dealing with HTML 5 elements.
An API for “implicit waits“: 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)
A revamped Firefox driver.
More shared code between Selenium and WebDriver.
You can now pass firefox profiles to the remote webdriver (this includes extensions and proxy settings!)
Improved .Net bindings: lots of updates to help bring them more in-line with the Java equivalents.

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!

Blog: Selenium 2.0a3 Released

Mon, 19 Apr 2010 00:00:00 +0000

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:

An improved remote protocol.
Updating the version of HtmlUnit used to 2.7.
Improved support for simulating user interactions with the browser via native events on Linux.
Better support for Firefox 3.6.
Bug fixes

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:

Android support
A new API to support writing tests involving complex user interactions.
Far more integration of the underlying architecture.