Selenide

Released Selenide 7.9.2

2025-05-08T00:00:00+00:00

Hiiiee!

White smoke has emerged, signalling a new release has been made: Selenide 7.9.2.

Fixed colors on video
Optimized video recorder
Attach video files
Updated to Selenium 4.32.0
Fixed ClassCastException
Slightly improved loops performance

Fixed colors on video

In November, we added video recorder to Selenide. This is an insanely useful feature for debugging tests, but turns out the generated videos had some color defects.

Before

On the left, there is the original web page. On the right - how it looked in videos:

Some colors have been changed, while others stayed the same. Possibly that’s why this issue went unnoticed for a while.

After

How the video looks like AFTER the fix:

Still not perfect, but the colors are fixed.

The only thing I had to do was to change one tiny true to false. ¯¯_(ツ)_/¯¯

Can you guess which exactly?

See issue 2973 and PR 3024.

Optimized video recorder

Now video recorder will consume significantly less CPU.

The initial implementation of the video recorder started rendering video immediately after test start. But in most cases, the test stays green, and the video file gets removed.

Now the video recorder will only take screenshots and store them to a temporary folder during the test. And only if the test fails, video rendering will be started.

Pros: Lower CPU usage
Cons: the final video will be ready a bit later.

See issue 3022 and PR 3024.

Attach video files

In the previous release, we added logging of screenshots in format [[ATTACHMENT|screenshot.png]], which is readable by GitLab and Jenkins (at least).

Now video files will be logged in the same manner:

[[ATTACHMENT|/projects/magura/build/reports/tests/1746735811373.0.webm]]

At least GitLab and Jenkins will automatically attach these files to build results.

See issue 2992 and PR 3024.

Updated to Selenium 4.32.0

Here is changelog, including:

Updated Selenium from 4.31.0 to 4.32.0
Updated CDP from 135 to 136

See PR 3020.

Fixed ClassCastException

Fixed ClassCastException in module selenide-appium. It happened if you added dependency selenide-appium (writing tests for mobile apps), but opened a web browser and called $.scroll(ScrollOptions).

See issue 3014 and PR 3015.

Slightly improved loops performance

Thanks to Luis Serna for PR 3013.

Peace be with you!

Andrei Solntsev

selenide.org

Released Selenide 7.9.0

2025-04-19T00:00:00+00:00

Hello, quadrobers!

We have released Selenide 7.9.0.

Attach screenshots to Jenkins and GitLab
Click holding keys
Upgrade to Selenium 4.31.0
Check for empty expected value

You know, tariffs set to rise to at least 104% on features import in Selenide… ¯¯_(ツ)_/¯¯

Attach screenshots to Jenkins and GitLab

When you run tests, Selenide automatically takes screenshots.

The path to the screenshot is added to the error message. This is very convenient when running locally, but when the tests are run on Gitlab, GitHub Actions or Jenkins, you still need to somehow save these files (archive, download artifacts, etc.).

This is solvable by few lines in build script, but now it will be solved even easier.

Now Selenide prints all the taken screenshots to the console in the following format:

[[ATTACHMENT|/path/to/screenshot.png]]
[[ATTACHMENT|/path/to/screenshot.html]]

At least GitLab and Jenkins understand this format and automatically save these files in build results.

See issue 2992. Thanks to Vivien Tintillier for PR 2998.

Click holding keys

Selenide has a method to click an element using JavaScript. Sometimes it can help to click an element that webdriver considers invisible, disabled etc.

Now you can click in this way, while “holding” down the ALT, CTRL, SHIFT or META keys:

import static org.openqa.selenium.Keys.*;

$("button").click(usingJavaScript());
$("button").click(usingJavaScript().holdingKeys(META));
$("button").click(usingJavaScript().holdingKeys(ALT, SHIFT));

See issue 2763 and PR 3008.

* Meta key has been designated as an extremist and is banned in the territory of the russian federation.

Upgrade to Selenium 4.31.0

There, it seems nothing serious happened. Just in case:

Updated Selenium from 4.30.0 to 4.31.0
Updated CDP from 134 to 135

See PR 2994.

Check for empty expected value

For the last 5 years, Selenide complains when you try to check en empty substring. Even IDEA highlights it as an error:

But it turned out that we forgot to do the same check for attributes: $.shouldHave(value("")). This expression is also meaningless, since any string contains an empty substring.

See PR 3007.

NB! To avoid repeating the same mistakes, we recommend to set

Configuration.textCheck = FULL_TEXT;

In Selenide 8.0.0 it will be enabled by default.

Andrei Solntsev

selenide.org

Released Selenide 7.8.0

2025-04-02T00:00:00+00:00

Mi amore, mi amore!

This evening, my outie released Selenide 7.8.0.

I am wondering if my innie will read this text tomorrow morning and get familiar with the new Selenide features?

New functions for Appium
Remove proxy filters
Annotation @ShadowHost
Combined attributes in reports
Upgraded to Selenium 4.30.0
News

New functions for Appium

For Appium users, we added three new functions:

activate an app,
terminate the app,
relaunch the app.

You can find all these methods in class SelenideAppium:

import static com.codeborne.selenide.appium.SelenideAppium.*;

activateApp("com.saucelabs.mydemoapp.rn");

terminateApp("com.saucelabs.mydemoapp.rn");
terminateApp("com.saucelabs.mydemoapp.rn", ofSeconds(10)); // with timeout

relaunchApp("com.saucelabs.mydemoapp.rn");
relaunchApp("com.saucelabs.mydemoapp.rn", ofSeconds(20)); // with timeout

Thanks to Aliaksandr Rasolka for PR 2964.

Remove proxy filters

Exactly 7 years ago, we added methods to add filters to intercept requests/responses in Selenide proxy.
They allowed you to log requests, mock or modify server responses, add headers, bypass authorization and even test security.

And now you can remove these filters.
It may be useful if some of such filters is needed only in a single test, but it interferes with others.

As usually, you can find sample usages in Selenide own tests:

// add filters
getSelenideProxy().addRequestFilter("proxy-usages.request", ...);
getSelenideProxy().addResponseFilter("proxy-usages.response", ...);

// ... here is your test logic ...

// remove filters that are not needed anymore
getSelenideProxy().removeRequestFilter("proxy-usages.request");
getSelenideProxy().removeResponseFilter("proxy-usages.response");

See PR 2981 and also BUP 481.

Annotation `@ShadowHost`

About 5 years ago we added methods for working with Shadow DOM.
You could find web elements inside Shadow DOM using the standard dollar method:

$(shadowCss("#anyButton", "#shadow-host")).click();

Later we added a recursive serarch inside shadow doms.

And now the same thing can be done not only through dollar, but also through the @ShadowHost annotation in page objects:

class PageObject {
  @ShadowHost(@FindBy(id = "shadow-host"))
  @FindBy(css = "#inputInShadow")
  SelenideElement input;

  @ShadowRoot
  @FindBy(css = "#shadow-container")
  ShadowContainer shadowContainer;
}

Thanks to Ilya Koshaleu for PR 2968.

Combined attributes in reports

A couple of years ago we added combined attributes for mobile tests.

Now we realized that they don’t look nice in reports.

For example, a simple check like this:

$.shouldHave(attribute(
  android("content-desc").ios("name"), 
  "To do or not to do"
));

Looked like this in reports:

Element should have attribute 
  com.codeborne.selenide.appium.conditions.CombinedAttribute@47b530e0
     ="To do or not to do"

Now it will look better:

Element should have attribute @content-desc|@name="To do or not to do"

See issue 2967 and PR 2971.

Upgraded to Selenium 4.30.0

Easy, bumped Selenium from 4.29.0 to 4.30.0, including CDP version increase from 133 to v134.

See PR 2979.

News

Book Java Testing Toolbox by Philip Riecks - it contains a chapter about Selenide!
Post about Selenide in Korean!

Por favore, por favore, expresso upgrado corneo!

Andrei Solntsev

selenide.org

Released Selenide 7.7.0

2025-01-07T00:00:00+00:00

Happy New Year everyone!

We started the year with a release Selenide 7.7.0.

Moon support
Method $.scroll() with parameters
Fixed Selenide on Java 22
MITM certificate for Selenide proxy

Added support for Moon

Once upon a time, the guys from Aerokube created Selenoid - it was like Selenium Grid on steroids. Selenoid could run browsers in Docker, shot videos and quickly became popular. Four years ago, we added support for Selenoid in Selenide.

Then the guys created Moon - a similar instrument, but in Kubernetes. And switched to it. And recently Selenoid maintenance was finally terminated:

This repository has been archived by the owner on Dec 17, 2024. It is now read-only.

And we were finally forced to implement Moon support. :)
Now you can - running browsers in Moon - download files from there and check the clipboard etc. - everything that Selenide can do with local browsers.

Getting started with it is easy:

Replace dependency com.codeborne:selenide:7.7.0 by com.codeborne:selenide-moon:7.7.0

Specify URL of your Moon installation:

Configuration.remote = "http://moon.aerokube.local/wd/hub";

That’s it. You can use corresponding methods in tests:

clipboard().shouldHave(content("John Wick"));
File report = $("#report").download(using(FOLDER).withExtension("pdf"));

See issue 2304 and PR 2924.

Added method `$.scroll()` with parameters

Selenide already had a few methods for scrolling a web page: $.scrollTo(), $.scrollIntoView(), $.scrollIntoCenter().

Now there is another, more universal method $.scroll(options), which can be given parameters for direction and distance in pixels:

$("#up").scroll(direction(UP));
$("#left").scroll(direction(LEFT).distance(1400));

See issue 2769. Thanks to donnieHub for PR 2809.

Fixed Selenide on Java 22

It suddenly turned out that Selenide tests (without proxy) do not work on Java 22.

To fix it, we had to add BrowserUpProxy dependency runtime scope (even if you don’t use proxy). It’s not perfect, but good enough as a quick fix. To fix it properly, it’ll require significant refactoring. :) But overall, nothing will change for you.

See issue 2910 and PR 2912.

Updated MITM certificate for Selenide proxy

Now that was epic.
For those who added the self-signed BrowserUpProxy certificate to their trusted certificates (I don’t know why), the tests suddenly broke with the arrival of 2025.

A long time ago, in 2015, someone in the BrowserMobProxy project generated a self-signed certificate for 10 years. And then in early January 2025, the certificate expired. And the project changed hands several times. And the authors are nowhere to be found. And there is no documentation left. :)

How great is that we are such good guys and quickly learned how to generate new certificates!

A big hello to whoever will have to step on this rake again in January 2035. ;)

Remember us when you open yesterday’s README in your Intellij IDEA 2034.3.1 and run tests on Java 45 LTS while sipping a pineapple latte on your veranda on the Moon.

See issue 457, PR 2930 and PR 458.

Happy New Year!

Make plans, but let unplanned things happen to you.

Everything will be fine someday.

Andrei Solntsev

selenide.org

Year summary

2025-01-03T00:00:00+00:00

Happy New Year!

Damn 2024 is finally over, time to take stock of the year.

Milestones
Elves
Wizards
Palantirs
Tribes
People

Milestones

This year we have released 18 versions (from 7.0.5 to 7.6.1) and implemented several important features:

Elves

These guys have been working tirelessly all year and putting presents under the tree. This job is extremely important for the project, despite the fact that their names are often not even visible in press releases, because many of these changes are internal or too technical. Sometimes they don’t even get merged at all.

But it is on them that Selenide rests!

Serhii Bryt

Boris Osipov

Petro Ovcharenko

Yaraslau Lazakovich

Aliaksandr Rasolka

donnieHub

added method $.scroll()

Daniil Moiseev

Erik Jõgi & Vlad Ogorodnik:

input event from select

Amuthan Sakthivel:

Talk Mutated Java Appium Client - Selenide Appium at AppiumConf 2024

Reviewing pull requests, criticizing changes, describing bugs - this is a lot of work, actually!
This work is invisible, but important.

Thanks to all of you!

Wizards

A significant event for Selenide is the appearance of the Playwrightium.

Playwright is currently on hype, we must admit. And people now have the opportunity to continue using Selenide, and change the implementation under the hood: on even days Selenium, on odd Playwright - as the devil takes them. :)

And again, thanks to Sergey Brit for Playwrightium!

Palantirs

This year, an important event happened for me: at the SeleniumConf conference, a report was given titled “How to migrate from Selenium to Selenide”. Imagine what a turn it is! :)
And what’s also great is that at another automation conference LambdaTest I talked about Selenide

Unfortunately, I manage to give presentations in English much less often than in Russian, so these two are an achievement. Selenide’s audience is growing all over the world. :)

By the way, this year we found videos about Selenide in Spanish and also in Turkish!

Tribes

This year I got around to adding a little to the list of companies using Selenide.
It was surprising that there is more companies from America, Europe and other word than I assumed!

People

The monthly number of downloads has broken a new record, rising from 877K last January to 1.3 million in October.

Happy New Year to you, and may no orcs cross your path!

Andrei Solntsev

selenide.org

Released Selenide 7.6.0

2024-11-24T00:00:00+00:00

Good evening!
We released Selenide 7.6.0 with something tasty and interesting.
Yo-yo, rush to update!

Videos are a serious thing. If there are videos, then they reflect something.

What’s new:

Added video recorder
because for webdriver conditions
Method $.scrollIntoCenter()
Special space characters support
Fixed inNewBrowser with custom configuration
Fixed appium page factory
Reduced the number of Selenide logs
Fixed Selenide.screenshot(filename) behaviour
JSR305 -> JSpecify
Simplified custom commands
Updated dependencies
News
Statistics

Added video recorder

Finally!

We all encounter unstable tests. Blinking tests. Flaky tests.

If this topic is new to you, I envy you. You are in for a fascinating dive into
Flaky Tests.

When investigating flaky tests, videos may be very helpful. And now Selenide can save videos from tests out of the box.

Few years ago, we used to use the VideoRecorder library by Sergey Pirogov a lot. But now Sergey is assembling drones for the Ukrainian Armed Forces and is not working on open source for the time being. Such are the times. :(

How to start recording videos?

It’s easy.

Replace dependency selenide:7.6.0 by selenide-video-recorder:7.6.0
Add extension org.selenide.videorecorder.junit5.VideoRecorderExtension to your tests (in case of JUnit5)
Add listener org.selenide.videorecorder.testng.VideoRecorderListener to your tests (in case, God forgive me, TestNG)
Add annotation @Video to your unstable tests (there aren’t many of them, are there?)

Now Selenide starts recording videos for all annotated tests.
BUT
the videos will be saved only when a test fails. A link to the video will be added to the error message - just as link to a screenshot.

Element should have text "Oreshnik"
Actual value: text="Kokoshnik"

Screenshot: file:/.../build/reports/tests/1732761758509.0.png
Page source: file:/.../build/reports/tests/1732761758509.0.html
Video: file:/.../build/reports/tests/1732761754743.0.webm

How it works?

Before every annotated test, Selenide starts 2 threads:

Regularly takes screenshots from web browser and stores in a queue (just in memory for now)
Merges the screenshots to a video (using library org.bytedeco:javacv)

After the test, the video is either deleted or saved to a file, and attached to the error message.

P.S. The abovementioned behaviour and some parameters can be configured in file selenide.properties, see VideoConfiguration.

NB! Keep in mind that video recording consumes resources and slows down your computer. Use sparingly.

See issue 2145. Thanks Sergey Brit for PR 2768,
Also see PR 2890 with annotations and configuration.

Added `because` for webdriver conditions

Now you can write not just:

webdriver().shouldHave(numberOfWindows(2)));
webdriver().shouldHave(url("https://dictionary.cambridge.org")));

but with an explanation:

webdriver().shouldHave(
  numberOfWindows(2).because("The login page should open in a new window"));

webdriver().shouldHave(
  url("https://dictionary.cambridge.org/").because("WTF is Oreshnik?"));

Thanks to Daniil Moiseev for PR 2853.

Added method `$.scrollIntoCenter()`

It’s essentially the same as $.scrollIntoView("{block: 'center'}") but shorter.

Because in most cases, when we scroll, that’s exactly what we want.

  $("#logout")
    .scrollIntoCenter()
    .shouldHave(text("A murky button somewhere at the bottom of the screen"))
    .click();

See PR 2842.

Special space characters support

When we search a web element by text, or verify the element’s text, we usually need to ignore spaces.

According to the HTML specification, several consecutive spaces are considered as one space.

Until now, Selenide treated several whitespace characters in this way (<space>, <tab>,  , <newline>). But it turned out that there are many more different distorted spaces (so-called “En Space”, “Em Space”, “Three-Per-Em Space” etc.). Now we can ignore them all. :)

For example, for a web page like this:

<div id="hero">
  Ahoo &#32; &nbsp; &ensp; &emsp; &numsp; &NoBreak; &puncsp; 
  &ThinSpace; &VeryThinSpace; &MediumSpace; Daryae
</div>

The following test will work:

  $("#hero").shouldHave(text("Ahoo Daryae"));

  $(byText("Ahoo Daryae")).ancestor().shouldHave(
    text("Say Her Name"));

Thanks to Daniil Moiseev for PR 2858.
See also PR 2884.

Fixed `inNewBrowser` with custom configuration

This is rarely used, so don’t bother. But I have to mention it.

First of all, we added method inNewBrowser with config parameter for opening a new browser with custom configuration:

inNewBrowser(Config config, Runnable lambda)

Second, we fixed the existing method inNewBrowser(Runnable lambda) which didn’t restore the previous config if the browser was closed inside it.

See issue 2859 and PR 2902.

Fixed appium page factory

Fixed bug in selenide-appium when a test tried to create page object for website, not mobile app. And website was not opened yet.

Thanks to Petro Ovcharenko for PR 2879.

Reduced the number of Selenide logs

We reviewed Selenide logs and converted some “info” logs into “debug”.
In other words, there should be less spam in the logs now.
If you need to debug some complex problem, turn on the “debug” level. ;)

See PR 2892.

Fixed `Selenide.screenshot(filename)` behaviour

In javadoc of this method, it was mentioned that it creates two files - “.html” and “.png”. But in reality it created only “*.png”. Now the behaviour of this method matches the description in javadoc.

See issue 2896 and PR 2901.

JSR305 -> JSpecify

Many Selenide methods were annotated with @Nullable, @Nonnull, @CheckReturnValue, @ParametersAreNonnullByDefault.
This is useful to help you avoid some typical bugs. Thanks to these annotations, IDE can highlight this code with a warning:

  $("h1");   // Ooops, somebody forgot a check: .shouldBe(visible)

Until now, we took these annotations from library “JSR 305” (the annotations were imported from package javax.annotation).
But this library is not supported anymore.And recently a new library JSpecify was released to replace it. Now Selenide migrated to JSpecify. The annotations are now imported from packages org.jspecify.annotations and com.google.errorprone.annotations.

See PR 2889.

Simplified custom commands

If you created a subclass from Click, SetValue or some other Selenide built-in command, then we accidentally broke your backwards compatibility. Sorry. :)

Now instead of method

public SelenideElement execute(SelenideElement proxy, WebElementSource locator, Object [] args) { ... }

you need to implement/override method

protected void execute(WebElementSource locator, Object @Nullable [] args) { ... }

But it’s shorter and simpler this way, right?

But in general, if your project compiles, then don’t worry, it doesn’t concern you. :)

See issue 2906 and PR 2889.

Updated dependencies

bump Selenium from 4.25.0 to 4.26.0 (incl. CDP 129 -> 130)
Bumps BrowserUpProxy from 2.2.19 to 3.0.0.
Bump LittleProxy from 2.3.0 to 2.3.2
Bump Netty from 4.1.113.Final to 4.1.115.Final
Bump Guava from 33.3.0-jre to 33.3.1-jre
Bump JUnit from 5.11.0 to 5.11.3
Bump Jackson from 2.17.2 to 2.18.1
Bump HttpClient from 5.4 to 5.4.1

News

Post What you didn’t know about Selenide by Serhii Bryt
Review of Selenide 7.5.1 by Borys Yevstyhneiev
UI Testing with Selenide in Oril blog, see video tutorial
new Selenide adapter,
Selenide-Java by Victor Hugo Fonseca

Statistics

Monthly Selenide downloads hit the new record: 1.3 millions in October!

Andrei Solntsev

selenide.org

Released Selenide 7.5.0

2024-09-15T00:00:00+00:00

Long time no see, cats!

I wrote the last release notes in April. Since then, we have made a few releases, the most significant was 7.4.0.

But now it’s time to upgrade to Selenide 7.5.0:

New configuration for every browser
Fixed events in selects
Shorter API for downloading files
Don’t close windows when downloading files
Don’t catch all Errors anymore
Fixed custom error formatters
Updated dependencies
News
Statistics

New configuration for every browser

Selenide has one nuance that might not be obvious to newcomers: all settings in Configuration class are static. When you change any setting in one test, it affects other tests as well. It may be especially important when running tests in parallel.

This is, so to speak, not a bug, but a feature: Configuration contains settings that, it seems, do not need to be changed from test to test. And those values that can actually be different, we have long ago taken out into the parameters of different methods:

$.click(usingJavaScript()); // instead of Configuration.clickViaJs = true
$.download(using(PROXY)); // instead of Configuration.fileDownload = PROXY

I wrote more about this evolution here.

But there was one more setting left: Configuration.browserCapabilities. Sometimes you need to set different capabilities in different tests - for example, to set the name of a video in Selenoid.

Strictly speaking, this was possible before as well - just by running the webdriver from your code with any necessary settings.
But now they can be set directly in the open method:

@Test void testWithoutProxy() {
  open("/one", new SelenideConfig().proxyEnabled(false).fileDownload(FOLDER));
  File report = $("#report").download();
}

@Test void testWithProxy() {
  open("/two", new SelenideConfig().proxyEnabled(true).fileDownload(PROXY));
  File cv = $("#cv").download();
}

Be careful not to overuse it.

NB! When you call method open(url, config), and some browser was already opened by that moment (apparently by a previous test), then Selenide will close this browser. This may slow down your tests due to constant reopening of browsers. Keep this in mind.

See issue 1372 and PR 2846.

Fixed events in selects

In Selenide 7.4.2 we improved working with <select>s in Vue.js: started throwing input events in addition to change. But we accidentally changed the events themselves: they were no longer “bubbleable”. That broke the processing of selects in some other frameworks (when the change event handler is bound not to select itself, but to its parent).

Now we fixed it. You can again choose options in your favorite selects in preferred way:

$("#migrants").selectOption("Abduct neighbours' pets");
$("#migrants").selectOptionContainingText("abbed ducks by their nec");
$("#migrants").selectOption(2);
$("#migrants").selectOptionByValue("kill-ducks-from-parks");

See issue 2832 and PR 2835.

Shorter API for downloading files

To download a “.txt”, you had to write quite a long expression:

File f = $.download(using(FOLDER).withFilter(withExtension("txt")));

No you can shorten it:

import static com.codeborne.selenide.DownloadOptions.file;

File f = $.download(file().withExtension("txt")));

In general, the algorithm is very easy: just write download(file(). - and after the period, available options pop up.

See PR 2841.

Don’t close windows when downloading files

Here is the story.
Selenide provides 4 methods for downloading files (HTTPGET, FOLDER, PROXY, CDP), and two of them (FOLDER, PROXY) work on this principle:

Click the link
Wait for the file
If some tabs/windows have been opened after click - close them
Return the file

And now we have come to the understanding that the third step is not really necessary. Nobody even remembers why it was originally added. ¯_(ツ)_/¯

Now Selenide will not even try to close any windows.
If you have a problem with this - contact us, we will discuss the details. :)

See issue 2836 and PR 2840.

Don’t catch all Errors anymore

And again we break the basics. :)
The main algorithm of Selenide is basically a try/catch in a loop (up to 4 seconds timeout). And here the crucial question: which exception should we catch inside this “try/catch”?

For many years, there was catch (Error error). By all accounts, this is bad practice in Java. :) Nobody remembers exactly why. Maybe it was because of Internet Explorer, which used to throw java.lang.Error in case of invalid XPath.

The problem is that this catch (Error error) can hide serious problems, in which the test should not retry in the loop, but immediately fail. Something like OutOfMemory errors.

Now we don’t catch Errors anymore and hope that it will not break your tests, because Internet Explorer has long since sunk into oblivion.

See PR 2845.

Fixed custom error formatters

Oh, never mind, too lazy to describe it. :)
If you override class SelenideErrorFormatter, then read issue 2830 and PR 2839.

Updated dependencies

bump BrowserUpProxy from 2.2.18 to 2.2.19
bump dnsjava from 3.6.0 to 3.6.1
bump LittleProxy from 2.2.4 to 2.3.0 (#2837)

News

My video How to migrate from Selenium to Selenide for more stable tests! from SeleniumConf 2024
My video Selenide: Enjoy Writing Automated Tests for Mobile & Web from Testμ 2024 conference (LambdaTest)
My video How to debug autotests from EpicHey conference 2023
Post Selenium or Selenide: Which Testing Framework Best Fits Your Needs?
Post Test smells: cleaning up E2E tests by Natalia Poliakova, Mikhail Lankin
Video about Selenide in Spanish by Jose Diaz
Video about Selenide in Turkish by Ahmet Bayram Ders
And finally, my video WTF Commit messages!

Statistics

Monthly Selenide downloads hit the new record: 1.154.002 in August!

Andrei Solntsev

selenide.org

Released Selenide 7.3.1

2024-04-28T00:00:00+00:00

Good morning!

We released Selenide 7.3.1.

It’s a tiny release, so it will be easy to upgrade. Let’s start the unboxing:

Mock response with specific content type
Fixed method $.clear() in mobile
Fixed error message when clicking an invalid link
Disabled Chrome warning about stolen password
Fix CDP downloading for custom webdrivers
Deprecated setting holdBrowserOpen
Upgraded Selenium from 4.19.1 to 4.20.0
Statistics

Mock response with specific content type

As you know, Selenide allows to mock server response using its built-in proxy server:

getSelenideProxy().responseMocker().mockText("cik-mock",
  urlStartsWith(GET, "https://cik.ru/api/gov/no/referendum"), 
  () -> "{votes: 2133326, for: 99.23, against: 0.77}");

You could specify any response content, but not type. But sometimes the type is important. Now you can specify any headers for the mocked server response, including Content-Type:

import org.openqa.selenium.remote.http.HttpResponse;

getSelenideProxy().proxyMocker().mockResponse("cik-mock", 
  urlStartsWith(GET, "https://cik.ru/api/gov/no/referendum"), () -> new HttpResponse()
      .setStatus(429)
      .addHeader("Content-Type", "application/json")
      .setContent(utf8String("{votes: 2133326, for: 99.23, against: 0.77}"))
  );

See issue 2705 and PR 2706.

Fixed method `$.clear()` in mobile

… for an element that exists in DOM, but not visible (or interactable).

It turns out that calling clear or click on mobile apps:

$("#hiddenElement").clear();

Failed with an incorrect message if the element is found, but not visible (for example, covered by another element):

Element should be interactable {By.name: ComputeSumButton}
Element: '<XCUIElementTypeButton ... visible="false">...

Caused by: 
  UnsupportedCommandException: 
    Unhandled endpoint: /session/28...13/element/07000000-0000-0000-CF35-000000000000/css/opacity ...

Now the message will be correct, without any UnsupportedCommandException:

Element should be visible {By.name: ComputeSumButton}

See issue 2722 and PR 2723.

Fixed error message when clicking an invalid link

A similar problem. If you try to click an invalid link in Firefox (for example, https://zopa):

  $("#invalid-link")
    .shouldHave(attribute("href", "https://zopa"))
    .click();

then Selenide generated an misleading error message:

Element not found {#link}
Expected: clickable: interactable and enabled

Now there will be an honest error text:

WebDriverException: Reached error page: about:neterror?e=dnsNotFound&u=https%3A//zopa/
                    Build info: version: '4.20.0', revision: '866c76ca80'

P.S. Interestingly, only Firefox produces this error. Other browsers calmly display a standard page with a text like this:

This site can’t be reached
Check if there is a typo in example.
DNS_PROBE_FINISHED_NXDOMAIN

See issue 2725 and PR 2727.

Disabled Chrome warning about stolen password

Again. We already disabled this annoying prompt in PR 2662, but there we added only setting profile.password_manager_enabled=false which was not enough. Now we also added setting profile.password_manager_leak_detection=false.

See PR 2729.

Fix CDP downloading for custom webdrivers

As you remember, few months ago we implemented another file downloading mechanism via CDP. Obviously, it works only in Chromium-based browsers.

But in case of custom webdrivers, the check “is this a Chromium” didn’t work:

Configuration.fileDownload = CDP;
Configuration.browser = MyCustomChromedriverFactory.class.getName();

File report = $("#report").download();
// threw an error: java.lang.IllegalArgumentException: 
// The browser you selected "MyTest$CustomWebDriverProvider" doesn't have Chrome Devtools protocol functionality.

Now Selenide properly detected Chromium-based browser using their actual capabilities.

Thanks Petr Ovcharenko for PR 2728.

Deprecated setting `holdBrowserOpen`

Selenide has setting holdBrowserOpen: when set to true, Selenide will not close the browser after finishing the tests. Sometimes people want to leave the browser opened to debug/investigate there something.

I personally never liked this feature, and now we’ve got a good reason to remove it. Suddenly we realized that the feature is harmful. When you finish the debugging and manually close the browser, nobody closes the webdriver. It will be hanging and consuming resources indefinitely.

Now flag holdBrowserOpen is deprecated. As a replacement, you can just add sleep(600_000) in your test - and the browser will stay opened for a long time.

See PR 2730.

Upgraded Selenium from 4.19.1 to 4.20.0

I don’t see too much changes in Selenium changelog, so nothing to fear. :) Among others, they added CDP 124 and removed 121.

See PR 2726.

Statistics

It happened!!!

The number of monthly downloads of Selenide has exceeded … a million!

Andrei Solntsev

selenide.org

Released Selenide 7.2.0

2024-02-27T00:00:00+00:00

Damn February.

To lift your spirits a bit, try to upgrade to Selenide 7.2.0:

Download files from Selenium Grid
Download files remotely using CDP
Collections for mobile tests
Disabled chrome warning about stolen password
Error message for element without href
Updated Selenium from 4.17.0 to 4.18.1

Download files from Selenium Grid

Finally!
Now you can download using FOLDER method from Selenium Grid.
Until now, FOLDER only worked for local browsers and Selenoid.

If you run tests in Selenium Grid and need to download files with FOLDER method, you just need to replace dependency

  com.codeborne:selenide:7.2.0

  com.codeborne:selenide-grid:7.2.0

And that’s basically it.

Configuration.remote = "https://qa.grid.my.com:4444/wd/hub";
Configuration.fileDownload = FOLDER;
File quotes = $("#quotes").download(withExtension("txt"));
assertThat(quotes.content()).contains(
  "Love is stronger than fear",
  "It's a shame to do nothing, it's a shame to allow yourself to be intimidated.");

See issue 1687, PR 2659 and PR 2660.

Download files remotely using CDP

In the previous release, we added method CDP for downloading files. But it worked only for local browsers.

Now it also works with remote browsers running on Selenoid or Selenium Grid.

Configuration.remote = "https://cloud.browsers.my.com:4444/wd/hub";
Configuration.fileDownload = CDP;
File places = $("#places").download(withExtension("csv"));
assertThat(places.content()).contains("Church of the Icon of the Mother of God", "Borisovskoye");

See issue 1687, issue 2550 and PR 2661.

Collections for mobile tests

We have piled up useful things for testing mobile applications. There are new methods for collections:

SelenideAppium.$$(By)
SelenideAppium.$$(Collection<WebElement>)

Both return an instance of SelenideAppiumCollection. This is basically the same as the old good ElementsCollection, but with SelenideAppiumElement instances instead of SelenideElement.

SelenideAppiumCollection poetry = $$(By.xpath("//android.widget.EditText")).shouldHave(size(2));
poetry.get(0).scroll(up()).setValue("and blood clots will fall into the sky");
poetry.get(1).scroll(down()).setValue("of crimson Kremlin towers");

Also, we added method SelenideAppium.$(WebElement webElement), but it’s unlikely to be useful to you.

See issue 2333 and PR 2656.

Disabled chrome warning about stolen password

After updating Chrome, this annoying dialog “The password… was found in a data breach” started popping up. It seems logical that nobody needs this popup in the tests.

Although this looks more like a Chrome 122 bug, we quickly disabled this popup - just in case.

See issue 2658 and PR 2662.

Error message for element without `href`

I suddenly realized why so many people struggle with setting up a proxy, and don’t even realize that Selenide has easier methods for downloading files: FOLDER and CDP.

Well, the problem might be in communication. All these years, method $.download() threw the following error message:

The element does not have href attribute: <a id="generate-report">

Seeing this message, people opened the first post from Google - which is 5 years old and mentioned only one alternative - PROXY. And they rushed to study the proxy.

Now the error message will indicate that there are multiple downloading methods:

The element does not have "href" attribute: <a id="generate-report">, so method HTTPGET cannot download the file.
Please try another download method: FOLDER, CDP or PROXY.
Read more about possible download methods: https://selenide.org/javadoc/current/com/codeborne/selenide/FileDownloadMode.html

However, I’m afraid this won’t help, because who reads them…

See PR 2653.

Updated Selenium from 4.17.0 to 4.18.1

See Selenium changelog and PR 2655.

Let’s hope for spring.

You’re not allowed to give up.
Don’t be discouraged and don’t give up.
Test automation is not a sprint, but a long and hard marathon.

Andrei Solntsev

selenide.org

Released Selenide 7.1.0

2024-02-07T00:00:00+00:00

Good evening! Happy New Year, happy new hopes!

Today we have a fresh shiny Selenide 7.1.0 one on the menu:

Download files with CDP
Condition animated
IF with timeout ¯¯_(ツ)_/¯¯
Click disabled elements
New method $.unfocus()
Fixed page load timeout in mobile tests
Add same proxy filter many times
Updated dependencies
Statistics

Download files with CDP

Less than three years have passed since CDP was introduced into Selenium, and we have already downloaded files using it! As you know, there are several ways to download files in Selenide: HTTPGET, FOLDER, PROXY. Now CDP has been added to them:

Configuration.fileDownload = CDP;
File f = $.download();

File f = $.download(using(CDP));

It works similarly to FOLDER: clicks the link and waits for the file to appear in the list of downloaded files. Only unlike FOLDER, CDP understands that the download is complete not by the file date, but by the Browser.downloadProgress event from the CDP.

Of course, this download method only works in Chromium browsers. And only on a local browser for now.

See issue 2550. Thanks to Sergey Brit for PR 2567.

NB! As a contributor, Sergey gets the right to tell you about a fund of his choice.

Word to Sergei:

I encourage you to donate to the fund ANGRY CORGI.

Angry Corgi is a charity run by tech folks from local Ukrainian companies.
Folks are aiming to ensure Air Defense computer infrastructure is sufficient to defend the military personnel and civilians from russian forces attacks. Their teams permanently collects laptops from people across the world and fundraises to purchase new tablets, TV sets and other network equipment for the units.

This is what we will now have as a glorious tradition. :)

Condition `animated` for waiting for the completion of an animation

Animated elements can cause a lot of unpleasant moments for QA engineers. Your test tries to click an element - but at this moment the element is moving, resizing, shrinking, expanding - what the hell. And the click hits another element.

More about animation in my video Flaky tests.

Now you can wait for the completion of animation using this command:

  $.shouldNotBe(animated);

We hope this helps make your tests more stable.

Thanks to Boris Osipov for PR 2556.

You may ask, how does selenide understand that the animation has ended? Take a look at the pull request, it’s interesting. In short, using the JS function requestAnimationFrame, selenide asks the browser for dimensions and coordinates of the element twice in a row (in two different rendering cycles), and checks that they have not changed. Tricky, huh?

Added IF with timeout ¯¯_(ツ)_/¯¯

We resisted for many years, but finally we allowed it to happen. :)

We added method $.is(condition, timeout) that returns boolean. Now in your tests you can write IFs without try/catch. The gates to hell have opened.

  if ($("#banner").is(visible, Duration.ofSeconds(2))) {
    $("#banner .close").click();
  }

For sure, the logic of this IF will explode many brains, so read carefully:

If the element is visible, it will immediately return true.
If the element is not visible, the method will wait for some time (but no more than given timeout), and if the element has appeared - will return true.
And only if the element still hasn’t appeared after the timeout, it will return false.

See issue 2590.
Eternal shame on my gray hairs for PR 2640!

NB! New method $.is(.., Duration.ofSeconds(8)) can be slow! In case of false result, it will always take 8 seconds! This is a deadly long time for tests. Please avoid such checks.

You can click disabled elements

Starting from version 6.15.0, Selenide doesn’t allow clicking disabled elements. But sometimes it might be needed (for example, ti check that clicking on such an element has no effect). Now you can bypass all checks and simply click on any element using the force parameter:

  $("#disabledButton").click(usingDefaultMethod().force());

Don’t overuse it.

See issue 2635 and PR 2636.

New method `$.unfocus()`

We added method $.unfocus() that removes focus from an element.

In fact, you could do it using method $.pressTab(), but it may have unwanted side effects. For example, another element suddenly could get focused. And sometimes, by pressing TAB, the form could be submitted altogether (for example, when entering an OTP code).

In that sense the new method $.unfocus() is safe: it just removes the focus from the element without focusing any other element.
Thus you can check the work of autocompletion, auto-formatting, hints, popups etc.

  $("#card-number").sendKeys("1111-222-33-4444").unfocus();
  $("#preview").shouldHave(text("Pay to 1111-***-**-***4 ?"));

See issue 2638 and PR 2639.

Fixed page load timeout in mobile tests

Selenide had a bug: it occasionally set property Configuration.pageLoadTimeout to 0 in mobile tests. But Appium doesn’t support such a setting. That’s why you could see these warnings in logs:

NotImplementedError: Not implemented yet for pageLoad

It’s not critical, it’s just a warning. Nevertheless, now we fixed it.

See issue 2612 and PR 2628.

Add same proxy filter many times

It has become a little easier to add your own filters for the Selenide proxy. Now you don’t have to check that such a filter has already been added earlier, but simply add it again each time:

  private static final RequestFilter REQUEST_LOGGER = new RequestFilter() {...}

  @BeforeEach
  final void setUp() {
    getSelenideProxy().addRequestFilter("request-logger", REQUEST_LOGGER);
  }

Previously, Selenide complained that such filter already exists. And now it will continue to work calmly (but only if it is really the same filter).

See issue 2617 and PR 2630.

Updated dependencies

bump JUnit from 5.10.1 to 5.10.2
bump TestNG from 7.8.0 to 7.9.0
Bump slf4jVersion from 2.0.11 to 2.0.12
Bump LittleProxy from 2.1.1 to 2.1.2

Statistics

The number of monthly downloads of Selenide has exceeded 911 thousand!

Wow.

And another interesting figure.

Selenide has one subproject selenide-appium for writing autotests for mobile phones. He didn’t use it much before in demand (compared to Selenide itself), but this year it has sharply increased.

I don’t know why this happens, but it’s cool. :)

Andrei Solntsev

selenide.org

Released Selenide 7.0.1

2023-10-26T00:00:00+00:00

Yesterday we released Selenide 7.0.0. I expected complains about Java 17, but…

no. Nobody complained about Java 17. And that’s great!
But people asked to restore loops over collections.

Well, in today update Selenide 7.0.1 we restored a couple of things:

Restore loops over collections
Restore method isEmpty() for collections
Return field self in containers
Renamed CollectionCondition to WebElementsCondition
UPD 7.0.2: Upgraded to Selenium 4.15.0

Restore loops over collections

Now you can use for loop again:

for (SelenideElement element : $$(".element")) {
  element.shouldBe(visible);
}

And I won’t tire of repeating that

DON’T DO IT!

Don’t use loops and ifs in tests!

If you want to collect the texts/attributes of all elements to check them - Selenide has “collection conditions” for that:

  $$(".errors").shouldHave(texts("One", "Two", "Three"));

  $$("#numbers option").shouldHave(attributes("value",
                   "one", "two", "three", "four", "five"));

If you haven’t found a suitable check for your needs, you can easily create your own custom condition. Just create a class inheriting WebElementsCondition and implement method check. That’s easy.
And you can reuse it in all your tests.

See PR 2533.

Restore method `isEmpty()` for collections

I still understand why, but people do you this method:

  boolean errorsFound = $$(".error").isEmpty();

See PR 2533.

Return field `self` in containers

In release 7.0.0, we removed class ElementsContainer. With this, you lost method getSelf(). I still find it strange, but people do you this method as well.

If this sounds like you, then you can replace the getSelf() method with a field annotated by @Self:

static class RadioButton implements Container {
  @Self
  SelenideElement label;

  @FindBy(tagName = "input[type=radio]")
  SelenideElement input;
}

See PR 2534.

Renamed `CollectionCondition` to `WebElementsCondition`

It affects you only if you have custom collection conditions.

Not a problem. Just replace extends CollectionCondition by WebElementsCondition.

See issue 2372 and PR 2533.

UPD 7.0.2: Upgraded to Selenium 4.15.0

We released Selenide 7.0.2 with upgrade to the latest Selenium 4.15.0.

Here is Selenium changelog.

See PR 2540.

Andrei Solntsev

selenide.org

Released Selenide 7.0.0

2023-10-25T00:00:00+00:00

Happy birthday!

Today is October 25. Today, 12 years ago the first commit in the Selenide project was created.

For the holiday, we released a major release Selenide 7.0.0 with the update immediately to Java 17.

Updated to Java 17
Updated dependencies
Static initialization deadlock
Actual value at the moment of check
Removed deprecated methods in Condition
Removed deprecated methods in CollectionCondition
Removed deprecated methods in ElementsCollection
Replaced deprecated ElementsContainer by Container
Replaced FileNotFoundException by FileNotDownloadedError
Renamed *Exception to *Error
Removed support for deprecated WebDriverEventListener
Removed deprecated Drag’n’drop methods
Removed deprecated methods $.getSelectedValue() and $.getSelectedText()
Removed deprecated TestNG annotations @Report and @GlobalTextReport
Other cleanup

Updated to Java 17

Wow!
This day came!

To use Selenide 7.+, you will need to compile & run your tests with Java 17+.

How cool is that, right?

I know some of you don’t like this decision. You are still forced to run tests on Java 8.

But we are not guilty. As you know, Selenium 4.14+ upgraded from Java 8 to Java 11. So it was not possible to stay on Java 8 anyway. You have to update to Java 11 at least.

Now, there is a very simple reasoning. In any Java project, the most complex update is from Java 8 to Java 11. Compared to this, updating from Java 11 to Java 17 is much more simple. There is nothing to do there, really.

So just update your Java!

Life is too short to continue fiddling with Java 8

See PR 2522.

Updated dependencies

Updated Selenium from 4.13.0 to 4.14.1 (PR 2505) - requires Java 11+
Updated Appium from 8.6.0 to 9.0.0 (PR 2505) - requires Java 11+
Updated TestNG from 7.4.0 to 7.8.0 (PR 2505) - requires Java 11+

Fixed static initialization deadlock

This was an old potential problem in Selenide: class Condition and any of its subclasses depended on each other.
Therefore, under certain circumstances, a deadlock could occur when these classes were loaded simultaneously. Very unlikely, but theoretically possible.

More details about static initialization deadlock.

To fix the problem, we had to rename the base class Condition to WebElementCondition.

Don’t worry, all your Condition.visible imports will remain unchanged.
But if you have custom conditions, you will need to replace extends Condition by extends WebElementCondition.

See issue 2372 and PR 2453.

Actual value at the moment of check

Here we are talking not about web elements’ checks, but “new generation” checks: url, localStorage etc.

webdriver().shouldHave(url("https://some.com/page.html"));
localStorage().shouldHave(item("mouse", "Jerry”));
sessionStorage().shouldHave(itemWithValue("mouse", "Jerry”));
clipboard().shouldHave(content("Remember me"));

Shortly, we made the error message in these checks more correct. Find details in issue 2500 and PR 2501.

Removed deprecated methods in `Condition`

Removed deprecated methods apply() and actualValue() in class Condition.

This will only affect you if you wrote your own custom checks. Now, instead of two methods apply() and actualValue(), you will need to implement only one method check.

See PR 2512.

Removed deprecated methods in `CollectionCondition`

Similarly to the previous change, it only affects you if you have custom checks for collections (extends CollectionCondition). Instead of two methods test and fail, you need to implement only one method check.

See PR 2520.

Removed deprecated methods in `ElementsCollection`

Be prepared for the shock.
Class ElementsCollection does not extend java.util.List anymore. From the very beginning, this inheritance occasionally added to ElementsCollection many unneeded methods (like remove(), removeRange, clear, subList and listIterator()) that we never intended to implement.
But users sometimes did use them. And even complained that these methods didn’t work.

Now we don’t have these methods and don’t have these problems.
Now $$ has only the methods we find useful. Amen.

P.S. If you have a loop over collection elements:

  for (SelenideElement el : $$("#selenide-users .user")) {
    el.shouldBe(visible);
  }

then it doesn’t compile anymore.

A fast solution is to add asFixedIterable() to $$:

  for (SelenideElement el : $$("#selenide-users .user").asFixedIterable()) {
    el.shouldBe(visible);
  }

But the right solution is to rewrite this code and avoid the loop. Most probably, you would better write your custom collection condition.

See PR 2513.

UPD From version 7.0.1, it compiles again.

Replaced deprecated class `ElementsContainer` by interface `Container`

If you extracted parts of your page objects to reusable containers (aka “widgets”), they usually inherited ElementsContainer:

class WeatherWidget extends ElementsContainer {
  @FindBy(id = "air")
  private SelenideElement airTemperature;
}

Now you will need to replace ElementsContainer by just Container:

class WeatherWidget implements Container {
  @FindBy(id = "air")
  private SelenideElement airTemperature;
}

Interface Container doesn’t have method getSelf() anymore. It had been @Deprecated for a long time. But if you still need it, we added a better alternative in Selenide 7.0.1: annotation @Self.

See PR 2523.

Replaced `FileNotFoundException` by `FileNotDownloadedError`

Before today, all methods like $.download() were declared as throws FileNotFoundException. And you had to suffer adding this pointless throws FileNotFoundException to your tests. Now you can clean up this trash and remove unnecessary catch (FileNotFoundException) if you had them.

Now methods like $.download() will throw FileNotDownloadedError which is inherited from AssertionError. You don’t need to declare nor catch it. If test could not download the file - test should fail.No additional processing is needed.

See PR 2526.

Renamed `Exception` to `Error`

Personally, I don’t think it matters at all.
But some users didn’t like that some of Selenide classes were named *Exception, but didn’t extend java.lang.Exception.

Well, we respect all opinions. Now Selenide classes inherited from java.lang.Error are named *Error.

See issue 2485 and PR 2530.

Removed support for deprecated `WebDriverEventListener`

We removed all methods like addListener() with a parameter of type org.openqa.selenium.support.events.WebDriverEventListener.

This class has been deprecated in Selenium for a long time.

You should use addListener() with parameter org.openqa.selenium.support.events.WebDriverListener instead.

See PR 2516.

Removed deprecated Drag’n’drop methods

Yet another cleanup. Just replace

$("#what").dragAndDropTo(where);

$("#what").dragAndDrop(to(where));

See PR 2519.

Removed deprecated methods `$.getSelectedValue()` and `$.getSelectedText()`

One more cleanup.

Replace $.getSelectedValue() by $.getSelectedOptionValue()
Replace $.getSelectedText() by $.getSelectedOptionText()

See PR 2521.

Removed deprecated TestNG annotations `@Report` and `@GlobalTextReport`

These annotations were not needed starting from Selenide 6.7.0. Just remove them. Yes, and delete TestNG, for that matter. ;)

See PR 2517.

Other cleanup

Few more cleanups:

Replace

new BearerTokenCredentials("pwd")

new BearerTokenCredentials("domain", "pwd")

Replace

$.should(appears);

$.should(appear);  // or just $.shouldBe(visible)

Replace

Selenide.open(url, BASIC, "username", "password");

Selenide.open(url, BASIC, new BasicAuthCredentials("username", "password"));

See PR 2518.

Towards progress!

Andrei Solntsev

selenide.org

Released Selenide 6.19.1

2023-10-18T00:00:00+00:00

Good morning!

The world is frozen in anticipation, big changes are coming! Selenide 7.0.0 will be coming soon with an update to Java 11.

The era of Java8 lambda cuckolds is passing

At last, we released the last version that can run on Java 8:

Selenide 6.19.1

Mostly there are dependency updates, primarily Appium 8.6.0:

bump Appium from 8.5.1 to 8.6.0 (#2494)
Bump BrowserUpProxy (#2510)
Bump Netty from 4.1.98.Final to 4.1.100.Final (#2484) (#2498)
Bump LittleProxy from 2.0.21 to 2.0.22 (#2491)
Bump Guava from 32.1.2-jre to 32.1.3-jre (#2499)
Bump Jackson from 2.15.2 to 2.15.3 (#2502) (#2503)
Bump commons-io from 2.13.0 to 2.14.0 (#2486)

Andrei Solntsev

selenide.org

Released Selenide 6.19.0

2023-09-28T00:00:00+00:00

Good Sunday!
At the end of September, we released Selenide 6.19.0.

New method `$.highlight()` for highlighting a web element

I feel like we’re opening another Pandora’s box, but what can we do?

Well, we’ve added a method to highlight an element.

What is it needed for?

In normal situations, there is no need. :)

When your tests just run automatically on CI, there is no need to watch them. No need to highlight anything.
But when you need to make a cool demo at a conference, or just show running tests to colleagues - here highlighting may be useful. Or when you are debugging some tricky flaky test where it’s unclear what and when is being clicked.

How exactly is it highlighted?

At the moment, we suggest two highlighting options: with a background (default) or a border.

import static com.codeborne.selenide.HighlightOptions.*;

$("h1").highlight();              // by default - background()
$("h1").highlight(background());  // colored background
$("h1").highlight(border());      // colored border

You can use your own style for background and border:

$("h1").highlight(background("rgb(85, 180, 250);"));
$("h1").highlight(border("3px solid blue"));

Or even use totally custom CSS for highlighting:

$("h1").highlight(style("color: white; background-color: red;"));

Further development

For now, the method only highlights the element you specify. In the future, it might be worth adding automatic highlighting for each element that is interacted with. Such highlighting would allow you to make an effective demo or debug a tricky error.

Share your ideas, we’ll think about it.

See issue 1277, issue 2395 and PR 2481.

Strip invisible spaces in collections

As you remember, in Selenide 6.16.0 we speeded up working with collections with the help of JavaScript snippets. It turned out that in doing so we slightly changed the behavior for elements containing invisible spaces and other tricky characters.

Let’s say we have the following element on our page:

<div id="status">
  <span> Fighting spirit </span>
  <span>  seething&nbsp;\u200Breality  </span>
</div>

Then a collection check like this:

$$("#status span").shouldHave(texts("Fighting spirit", "seething reality"));

failed:

Expected :[Fighting spirit, seething reality]
Actual   :[Fighting spirit, seething reality]

Moreover, the message looks as if the texts are the same. But in the first line there is a regular space, and in the second there is an invisible space “”.

Now Selenide will clean up the invisible spaces. Perhaps it’s arguable whether it’s right or wrong, but it meets WebDriver specification, and Selenium also works like this. And we will also comply.

See issue 2469 and PR 2482.
Thanks to Maksim Au6ojlut for the hint about spaces.

Upgrade to Selenium 4.13.0

Upgraded Selenium from 4.12.1 to 4.13.0
Here is Selenium changelog.

It contains several important bugfixes, and still runs on Java8. Catch it before he starts requiring Java 11+!

See PR 2479.

Removed strict check for “/wd/hub”

If you use Selenoid, you might notice that selenide-selenoid plugin checked that URL ends with a string /wd/hub. It turns out that URL may be different. So we removed this check.

See issue 2475.
Thanks Dmitry Plodukhin for PR 2476.

Replaced `ElementsContainer` by `Container`

In a recent release, we forbid page objects to inherit ElementsContainer.

This code doesn’t work anymore:

class LoginPage extends ElementsContainer {
}

I still insist that a page object doesn’t really need to extend ElementsContainer. But few users complained that they cannot rewrite their code because of legacy etc.
For such project, we created interface Container:

class LoginPage implements Container {
}

For the usual widgets, we also recommend changing extends ElementsContainer to implements Container.

The only difference is that it’s interface, not an abstract class (you need to write “implements” instead of “extends”), and it doesn’t have method getSelf(). And you shouldn’t really need it.

See issue 2439 and PR 2465.

Methods `$.tap()`, `$.doubleTap()` for mobile apps

import static com.codeborne.selenide.appium.SelenideAppium.$;

$(By.name("ComputeSumButton")).tap();
$(AppiumBy.xpath("//android.widget.Button")).doubleTap();
$(AppiumBy.xpath(".//*[@text='People Names']")).tap(longPressFor(ofSeconds(4)));

Thanks qwez for PR 2467.

Selector by class+index for mobile apps

import static com.codeborne.selenide.appium.AppiumSelectors.byClassNameAndIndex;
import static com.codeborne.selenide.appium.SelenideAppium.$;

$(byClassNameAndIndex("android.widget.TextView", 7)).tap();

Thanks to Amuthan Sakthivel for PR 2440.

News

Selenium logger - a new project from Titus Fortner
Introduction to Selenide - The historical moment! A post about Selenide on the legendary resource Baeldung.
Selenide appium - A video about Selenide from the last LambdaTest conference by Amuthan Sakthivel
Selenide test automation: using Selenoid in docker by Dora & Margarita
Things to keep in mind when using Selenide - post about Selenide in Japanese by nilwurtz
Intro to Selenide By Updates4Devs.com

Andrei Solntsev

selenide.org

Released Selenide 6.18.0

2023-09-06T00:00:00+00:00

Good night!

Good news.
We released Selenide 6.18.0.

Show actual texts in collections

In Selenide 6.16.0, we speed up collections checks.

$$(".troubles").shouldHave(texts(
  "Health", "Emptiness", 
  "Financial Crisis", "Career Pressure"));

One of the optimizations was: if collection size doesn’t match the number of expected texts, Selenide doesn’t even start loading texts of elements, but immediately throws an error:

List size mismatch: expected: = 4, actual: 3

But people started complaining that they want to see the actual text even in this case.
This seems to be a case where convenience is more important than speed. And your tests don’t fail too often, right? ;)

That’s why we will show both sizes and texts from this release:

List size mismatch (expected: 4, actual: 3)
Actual (3): [Health, Emptiness, Financial Crisis]
Expected (4): [Health, Emptiness, Financial Crisis, Career Pressure]

See issue 2434 and PR 2456.

Updated Selenium from 4.11.0 to 4.12.1

Changelog is here. Among others, it fixes that deadlock in devtools, because of which we had to make the previous release.

See PR 2452.

Restore BasicAuth via DevTools

In Selenide 6.16.0, we implemented BasicAuth authentication via HasAuthentication mechanism (in Chromium-based browsers).

Later we had to roll it back due to the aforementioned deadlock in webdriver.
Now Selenium has been updated, the deadlock has been fixed, and we have returned the authorization back.

See issue 2336, PR 2358 and PR 2452.

Added method `$$.getOptions()`

Selenide has method $$.getSelectedOptions() which returns selected options of a <select> element.
Now we added a similar method $$.getOptions(), which returns all options.

$("select#hero").getOptions()
  .shouldHave(texts("Frodo", "Samwise", "Peregrin", "Meriadoc"));

$("select#hero").selectOption("Samwise");

$("select#hero").getSelectedOptions()
  .shouldHave(texts("Samwise"));

See issue 2445 and PR 2446.

Method `getFocusedElement()` made lazy

Now method Selenide.getFocusedElement() returns SelenideElement instead of WebElement.

It effectively means lazy initialization, re-tries, “should*” checks etc.:

getFocusedElement()
  .shouldHave(tagName("input"), id("otpCode"));

See PR 2454.

Added support for `SelenideAppiumElement` fields in page objects

If you write tests for mobile apps using our plugin selenide-appium, now you can declare fields in your page objects with type SelenideAppiumElement instead of SelenideElement.

It gives you some additional mobile-specific methods like hideKeyboard(), swipe() etc.

class LoginPage {
  @AndroidFindBy(accessibility = "Username input field")
  SelenideAppiumElement login;

  @AndroidFindBy(accessibility = "Password input field")
  SelenideElement password;
  
  public void login() {
    password.swipeTo();
  }
}

See issue 2437 and PR 2438.

Precise scrolling in mobile apps

Continuing the theme of mobile phones. In plugin selenide-appium, there is method scroll:

import static com.codeborne.selenide.appium.AppiumScrollOptions.with;

$.scroll(with(UP, 20)); // swipe up, no more than 20 times

Now you can specify the starting and ending position for the swipe (percentage of screen height):

import static com.codeborne.selenide.appium.AppiumScrollOptions.up;

$.scroll(up(10, 80)); // swipe from 10% point to 80% point

Thanks to qwez for PR 2449.

Don’t inherit page objects from `ElementsContainer`

Some users complained about this warning from Selenide:

WARN com.codeborne.selenide.impl.SelenidePageFactory - Cannot initialize field private com.codeborne.selenide.SelenideElement com.codeborne.selenide.ElementsContainer.self

We realized it happens when you inherit a page object from ElementsContainer:

class LoginPage extends ElementsContainer {
}

Which is not really needed. In fact, you cannot do it anymore. :)

Initially, ElementsContainer was intended to declare components inside page objects:

class LoginPage {
  @FindBy(id="weather")
  WeatherWidget weatherWidget;
}

class WeatherWidget extends ElementsContainer {
  @FindBy(id="temperature")
  SelenideElement temperature;
}

Just remove extends ElementsContainer from your page objects, and everything just works.

P.S. The point is, that these objects have different lifecycle:

Page objects can be created using method page: like, LoginPage page = Selenide.page();. And method page does NOT require your class to extend ElementsContainer.
And some fields of your page object can extend ElementsContainer. It makes Selenide search @FindBy elements inside of these classes.

See issue 2439 and PR 2455.

Updated dependencies

bump LittleProxy from 2.0.19 to 2.0.20 (fixes a memory leak in Selenide proxy)
update vulnerable jackson dependency - see PR 2442

Statistics

The number of monthly downloads of Selenide has exceeded 670 thousands!

It’s getting serious…

Andrei Solntsev

selenide.org

Released Selenide 6.17.2

2023-08-24T00:00:00+00:00

Good evening!

Today is August, 24 - Ukraine Independence Day.
And in honor of this holiday - a small release Selenide 6.17.2.

Un-hanged the hanging webdriver. Again.

In the previous release, we fixed the problem with hanging webdriver for most users.
But the unfortunate ones remained, who are forced to open the tested sites in Chrome through BasicAuth. For these users, webdriver still hangs.

What was left for us? We had to revert CDP-based authentication until the webdriver issue gets fixed.

How to reproduce the problem

If you want to reproeuce the problem, run this test:

  public class BasicAuthTest {
    @RepeatedTest(2)
    void this_snippet_hangs_during_second_run() {
      open("https://the-internet.herokuapp.com/basic_auth", BASIC, 
           new BasicAuthCredentials("the-internet.herokuapp.com", "admin", "admin"));

      $("#content").shouldHave(text("Congratulations!"));
    }
  }

The first run works, the second run hangs. On Selenide 6.17.1.

And on Selenide 6.17.2 it doesn’t freeze anymore. Hooray.

Andrei Solntsev

selenide.org

Released Selenide 6.17.1

2023-08-20T00:00:00+00:00

Good morning! Today is August, 20 - Restoration of Independence day in Estonia.

In honor of this holiday - a small release Selenide 6.17.1!

Un-hang hanging webdriver
Added support for $.type() in mobile apps
Fixed method $.type(Keys.*)
Removed spaces from $$.texts()

Un-hang hanging webdriver

In Selenide 6.16.0 (PR 2358), we occasionally introduced a bug that caused webdriver hanging in some situations. More exactly, if you call open(url, pageClass) twice, then webdriver hangs forever.

Wow. :)

  @Test
  public void this_snippet_hangs() {
    Selenide.open("https://www.google.com/", GooglePage.class);
    Selenide.open("https://www.google.com/", GooglePage.class);
  }

In fact, I found that this is a bug in webdriver, because it’s reproducible with pure Selenium. And changes in Selenide 6.16.0 just made it easily reproducible.

Now we fixed this problem for most users (but not for all).
We will wait for the full fix on webdriver side.

See issue 2424 and PR 2428.

Huge thans for extryd for a concise problem description with steps to reproduce. Such a description is an invaluable help to maintainers. I wish all tickets were like this!

Added support for `$.type()` in mobile apps

In a previous release, we added method type:

  $.type("Type me slowly with delays");

that types the text slowly, with delays. Useful for testing autocompletion, search etc.

But it turned out that it didn’t work in mobile apps (selenide-appium). Now it will work.

See issue and PR 2408.

Fixed method `$.type(Keys.*)`

The abovementioned method type method accepts not only strings, but also CharSequence. Which means this code should also work:

  import org.openqa.selenium.Keys;

  $("input").type(Keys.ENTER);

But it was broken because tried to case Keys.ENTER (which is CharSequence) to type String. Now it works (though it’s still not clear why it might be useful).

Thanks to Oleg Berezhnoy for observation and issue 2422.
Fixed in PR 2421.

Removed leading/trailing spaces from `$$.texts()`

In Selenide 6.16.0, we accelerated work with collections with a help of JavaScript code.
But abovementioned Oleg Berezhnoy revealed that we occasionally changes the behaviour of method $$.texts(). Before, it returned texts of elements without leading and trailing spaces:

  assertThat($$(".burnees").texts()).isEqualTo(List.of(
    "SIG",
    "Olenegorsky Gornyak",
    "Air base Soltsy",
    "Chongar bridges",
    "Henichesk Bridge"
  ));

And starting from 6.16.0, it returned texts with leading/trailing spaces:

  assertThat($$(".burnees").texts()).isEqualTo(List.of(
    "  SIG   ",
    "    Olenegorsky Gornyak   ",
    "       Air base Soltsy      ",
    "          Chongar bridges       ",
    "              Henichesk Bridge       "
  ));

This is perhaps a disputable which one is correct, but this is how the standard WebElement.getText() method works. So we didn’t argue. Now $$.texts() trims head and tail spaces again.

See issue 2419 and PR 2427.

Andrei Solntsev

selenide.org

Released Selenide 6.17.0

2023-08-02T00:00:00+00:00

Good morning!

Don’t wait to upgrade to Selenide 6.17.0!

Upgraded to Selenium 4.11.0
Replaced WebDriverManager by SeleniumManager
Restored support for Java 8
Added method $.type() for slow typing
For mobile apps: click with long press
For mobile apps: swipe left and right
Statistics

Upgraded to Selenium 4.11.0

We upgraded Selenium version from 4.10.0 to 4.11.0.

Read the full Selenium changelog here.

See PR 2393.

Replaced WebDriverManager by SeleniumManager

Starting from version 4.6.0, Selenium has built-in tool for downloading webdriver binaries - SeleniumManager. Afaik, it’s developed by the same Boni Garcia, who created WebDriverManager. But now it’s an official part of Selenium project.

Restored support for Java 8

In the last release, Selenide occasionally started requiring Java 11. It happened because of WebDriverManager update mentioned before.

Now it’s gone: no WebDriverManager - no problems. :)

Oldschoolers, you can run your tests on Java 8 again.

Nevertheless, I recommend you to upgrade to Java 11
(or even better to Java 17).
In the following autumn, Selenium will upgrade to Java 11 anyway, and then you will definitely have no choice.

See issue 2385 and PR 2400.

Added method `$.type()` for slow typing

This feature has been requested for a very long time. And finally!

Method $.type() does almost the same as $.sendKeys(), but slowly. With delays between key presses. It emulates like a real user is typing a text. May be useful for testing autocompletion, automated suggestions, hints, validation etc.

import static com.codeborne.selenide.TypeOptions.*;

$("#query").type("Who the fuck is yevgeny prigozhin");
$("#query").type(text("Who the fuck is dmitry utkin"));
$("#query").type(text("Who the fuck is lvova-belova").withDelay(ofMillis(100)));

By default, the delay between key presses is 200 milliseconds.

Thanks to Amuthan Sakthivel for PR 2191.

For mobile apps: click with long press

Now you can use this gesture when testing mobile apps:

import static com.codeborne.selenide.appium.SelenideAppium.$;
import static com.codeborne.selenide.appium.AppiumClickOptions.*;

$.click(longPress()); // by default 3 seconds
$.click(longPressFor(Duration.ofSeconds(4)));

See issue 2370. Thanks to Amuthan Sakthivel for PR 2381.

For mobile apps: swipe left and right

Now you can use this gesture when testing mobile apps:

import static com.codeborne.selenide.appium.SelenideAppium.$;
import static com.codeborne.selenide.appium.AppiumSwipeOptions.*;

$.swipeTo(); // by default swipes to the right
$.swipe(right());
$.swipe(right(20));
$.swipe(left());
$.swipe(left(30));

Thanks to Amuthan Sakthivel for PR 2369.

So, update, try and share:

How do you like SeleniumManager?
Everything is broken, or we can live with it?

Statistics

Monthly downloads count of selenide.jar exceeded 649 thousands!

(The previous record was in March: 602 thousand)

Andrei Solntsev

selenide.org

Released Selenide 6.16.1

2023-07-24T00:00:00+00:00

Hello, people!

We released a small update Selenide 6.16.1.

Added conditions allOf and anyOf
Added checks for cookies
Updated WebDriverManager
Fixed support for <tspan> in SVG

Added conditions `allOf` and `anyOf`

Now you can check one of conditions (OR):

$("#president").shouldHave(anyOf(text("Lowlife"), text("Cowardly bum")));

(in fact, Selenide already had method Condition.or for the same purpose, but anyOf seems to be easier to use).

Also, you can check all conditions (AND):

$("#president").shouldHave(allOf(text("a catastrophic character"), text("another six years of this cowardly bum in power")));

(in fact, it’s the same as just $("#president").shouldHave(text(..), text(..)), but the result of allOf can be extracted to a variable or method and reused, thus creating your own DSL).

Thanks to Evgenii Plugatar and PR 2368.

Added checks for cookies

Now you can check cookies in browser:

import static com.codeborne.selenide.Selenide.webdriver;

webdriver().shouldHave(cookie("session_id"));
webdriver().shouldHave(cookie("session_id", "1234567890"));
webdriver().shouldHave(cookie("session_id", "1234567890", Duration.ofSeconds(10)));

With built-in waiting, custom timeout, automated screenshot - everything you like.

Thanks to adorne for PR 2367.

Updated WebDriverManager from 5.4.0 to 5.4.1

Among others, it has support for Chrome 115 which caused a problem for many users.

See PR 2374.

P.S. On macOS, Chrome 115 still causes a error:

SessionNotCreatedException: Could not start a new session.  
  Response code 500.  
    Message: unknown error: cannot find Chrome binary 

It’s a known chromedriver bug. They promised to fix it soon.

Fixed support for `<tspan>` in SVG

Have you ever checked texts inside SVG? Me neither. And it turns out SVG can contain texts!

  <svg>
    <text x="10" y="30" class="small">
      People want to see <tspan>gratitude</tspan>.
    </text>
  
    <text x="10" y="60" class="small">
      We are not <tspan>Amazon</tspan> warehouse.
    </text>
  
    <text x="10" y="90" class="small">
      Thank you, <tspan>Ben Wallace</tspan>!
    </text>
  </svg>

Now you can check these texts again:

  $$("svg tspan").shouldHave(texts("gratitude", "Amazon", "Ben Wallace"));

See issue 2377 and PR 2379.

Andrei Solntsev

selenide.org

Released Selenide 6.16.0

2023-07-02T00:00:00+00:00

Good night!

I have an offer for you that you shouldn’t refuse.

Upgrade to Selenide 6.16.0!

Speed up collection checks
Error messages in collection checks
New date checks date(...) and datetime(...)
New methods for setting time
Full stacktrace in soft asserts
BasicAuth in Chromium browsers
Multiple domains in BasicAuth
Fixed $.doubleClick() in Appium
Take screenshot earlier
Updated dependencies
News

Speed up collection checks

Here is the coolness!

One of basic Selenide features is collection checks. With just one line you can check a bunch of elements:

$$("option").shouldHave(texts("Gandalf", "Gendalf", "Gondalf"))

But such a check can take a significant time in case of big collections.

For example, if a page has 1000 <option> elements, that check takes ~3 seconds on my machine.
The slowness is due to the fact that Selenide fetches the text of each element separately. 1000 webdriver calls, even very fast ones, takes its time.

It’s time to speed up those checks!

Now Selenide fetches texts of all 1000 elements with a single webdriver call using JavaScript.

Now that check takes 200ms instead of 3 seconds.
It became 15 times faster!
That’s crazy.

P.S. For Appium and other webdriver not supporting JS, Selenide will fall back to the old implementation (fetches texts one-by-one). At least it’s not worse than before.

See PR 2362.

Improved error messages in collection checks

During the previous refactoring, we improved error message for collections. Now Selenide provides a more detailed error of which element didn’t meet the conditions:

For example, this check:

$$(".number").shouldHave(exactTexts("On", "Tw", "Thre"))

Reported just a simple "Texts mismatch" message:

Texts mismatch
Actual: [One, Two, Three]
Expected: [On, Tw, Thre]

And now it specifies what exactly didn’t match:

Text #0 mismatch (expected: "On", actual: "One")
Actual: [One, Two, Three]
Expected: [On, Tw, Thre]

See PR 2362.

New date checks `date(...)` and `datetime(...)`

import static com.codeborne.selenide.conditions.datetime.DateConditionOptions.*;

LocalDate birthday = LocalDate.of(2022, 10, 11);
$("#birthdate").shouldHave(date(birthday));
$("#birthdate").shouldHave(date(birthday, "yyyy-MM-dd"));
$("#birthdate").shouldHave(dateBetween(parse("2020-01-01"), parse("2023-12-31")));
$("#birthdate").shouldHave(dateFormat("yyyy-MM-dd"));

See issue 2268. Thanks to Maksim @Au6ojlut for PR 2281.

New methods for setting time

Selenide had a method for selecting a date (withDate):

$("#birthdate").setValue(withDate(LocalDate.of(...)));
// for <input type="date">

Now we have similar methods for selecting date and time (withDateTime):

$("#birthdate").setValue(withDateTime(LocalDateTime.of(...)));
// for <input type="datetime-local">

or only time (withTime):

$("#openFrom").setValue(withTime(LocalTime.of(7, 12)));
$("#closeFrom").setValue(withTime(LocalTime.of(17, 59, 58)));
// for <input type="time">

See PR 2357.

Full stacktrace in soft asserts

In Selenide, you can enable soft asserts mode. Then Selenide will collect several failures during a test, and throw an exception in the end. This exception will include all collected assertion errors.

The problem is that Selenide didn’t show full stacktraces, so you couldn’t see the “Caused by:” part. Now it will be shown.
Be prepared for the lengthy stack traces :)

See issue 2350 and PR 2354.

Improved BasicAuth in Chromium browsers

Selenide has methods for BasicAuth authentication:

open("/basic-auth/hello", "my.test.com", "scott", "pwd123");

Until now, we had two BasicAuth implementations.

If proxy is enabled: Selenide adds an Authorization header to every http request (Basic YWRtaW460JrQsNC30LrQvtCy0LAg0LTRltCx0YDQvtCy0LA=).
If proxy is disabled: Selenide adds login+password to URL (https://scott:pwd123@localhost:42220/basic-auth/hello).

Now we have a third implementation. If webdriver implements interface org.openqa.selenium.HasAuthentication, then Selenide adds login+password via this interface. Basically it means Chromium based browsers (Chrome, Chromium, Edge).

See issue 2336 and PR 2358.

Multiple domains in BasicAuth

Until now, you could set only one domain for BasicAuth:

open("/basic-auth/hello", "my.test.com", "scott", "pwd123");

It doesn’t help if AUT uses multiple domains. For example, if AUT at address “https://my.test.com” opens a frame with address “https://api.test.com” or, say, “https://api.test.com”. You can set an empty domain, but it’s not always safe.

Now you can set multiple domains separated by comma or “|”:

open("/basic-auth/hello", "my.test.com|auth.test.com|api.test.com", 
          "scott", "pwd123");

See PR 2358.

P.S. Of course, the domain name is not used when Selenide adds the login+password just to the URL.

Fixed `$.doubleClick()` in Appium

In a previous release we broke, and now we’ve fixed the double click in mobile phones:

$(AppiumBy.xpath(".//android.widget.CheckBox")).doubleClick();

See issue 2346 and PR 2347.

Take screenshot earlier

Usually Selenide takes a screenshot after a test failure.
BUT If you close the browser in @AfterEach method, Selenide could not take the screenshot anymore:

@AfterEach
void tearDown() {
  Selenide.closeWebDriver();
}

Now Selenide will take the screenshot earlier - BEFORE all @AfterEach methods.

See issue 2352 and PR 2356.

Updated dependencies

2319 use latest version of geckodriver for FF 102+
2328 bump Selenium from 4.9.1 to 4.10.0
2324 Bump io.appium:java-client from 8.5.0 to 8.5.1
2349 Bump Netty from 4.1.93.Final to 4.1.94.Final
bump WebDriverManager from 5.3.3 to 5.4.0

News

Video Run Selenide Appium Test in LambdaTest in blog “Testing Mini Bytes”
Number of monthly downloads of Selenide is still around 600 thousands!

Andrei Solntsev

selenide.org

Released Selenide 6.15.0

2023-05-29T00:00:00+00:00

Good night!

We released Selenide 6.15.0 with quite serious internal changes.

Merged project selenide-selenoid into selenide
Merged project selenide-appium into selenide
Click checks that element is not disabled
Escape newlines in text report
Combined selectors for mobile apps
New checks for mobile apps
New selectors for mobile apps
Switch context in mobile apps
Refactoring of CollectionCondition
News

Merged project `selenide-selenoid` into `selenide`

This allows us to easily change and release these projects. For you, the dependency declaration will change.

Instead of

  testImplementation("org.selenide:selenide-selenoid:2.3.7")

You will need to use:

  testImplementation("com.codeborne:selenide-selenoid:6.15.0")

See PR 2292.

Merged project `selenide-appium` into `selenide`

This allows us to easily change and release these projects. For you, just the dependency version will change.

You will need to update selenide-appium from 2.8.1 to 6.15.0.

See PR 2291.

Now Click checks that the element is not disabled

As you know, method $.click() first checks that the element is visible (more specifically, the element should be either visible or have css property opacity: 0).

BUT until now, Selenide didn’t check that the element is enabled. In other words,

Selenide did allow to click disabled elements.

Argument in favor of this decision: what if test author does want to click the disabled element and make sure that nothing happens?
Argument against this decision: this behavior can cause flaky tests:
- the test clicks a button without waiting until the buttons gets enabled;
- de-facto click didn’t happen (but no errors were thrown);
- and later the test fails because the click didn’t happen (and it will be very hard to understand why the test failed).
- or even worse: the test may remain false positive.

So now argument #2 has won. Now method $.click() will wait until the element gets enabled.
If the element is not enabled, the click will fail.

Now you can shorten your tests even more:

Replace $.shouldBe(enabled).click() by just $.click().

P.S. If you’re in the #1 camp, you can use $.shouldBe(disabled) instead of clicking.

See issue 2288. Thanks to Maksim @Au6ojlut for PR 2290.

Escape newlines in text report

If you tried using a multi-line string in your test:

$.shouldHave(text("Hello\n multi\n line\n world");

Then you might have noticed that in the report this line looked clumsy and broke the entire table.

Now it will look good.

See issue 2283. Thanks to Maksim @Au6ojlut for PR 2284.

Combined selectors for mobile apps

When testing mobile apps, it would be convenient to use two selectors in a check: one for Android, and the other for iOS.
Previously, you had to come up with helper methods or use IFs in tests.

Now you can use a single selector using CombinedBy:

import static com.codeborne.selenide.appium.selector.CombinedBy.android;
import static com.codeborne.selenide.appium.AppiumSelectors.byTagAndName;

$(android(byText("Hello, Android user!")).ios(byText("Hello, iOS user!")))
  .shouldHave(text("Hello, Android user!"));

New checks for mobile apps

A similar solution for checks: now you can declare a single check for Android, and iOS using class CombinedAttribute:

import static com.codeborne.selenide.appium.conditions.CombinedAttribute.android;
import static com.codeborne.selenide.appium.AppiumCondition.attribute;
import static io.appium.java_client.AppiumBy.accessibilityId;

// A single element check:
$.shouldHave(attribute(
  android("content-desc").ios("name"), 
  "To do or not to do"
));

// A collection check:
$$.shouldHave(attributes(android("text"), 
  "First", 
  "Second", 
  "Third"
));

New selectors for mobile apps

We also added a bunch of selectors to find mobile elements by tag, text, substring etc.:

import static com.codeborne.selenide.appium.AppiumSelectors.*;

$(byAttribute("content-desc", "Hello")).click();
$(byContentDescription("Hello")).click();
$(byTagAndAtttribute("android.widget.TextView", "Good")).click();
$(byTagAndName("XCUIElementTypeStaticText", "bye")).click();
$(withTagAndName("XCUIElementTypeText", "ugly xpath world")).click();

See issue 2300. Thanks to Amuthan Sakthivel for PR 135. See also PR 2315.

Switch context in mobile apps

Mobile apps often open some content in an embedded web browser (WebView). Sometimes mobile apps work entire in WebView. When testing such apps, you often need to switch between “native” and “web” context.

Now we have convenient methods to switch between contexts:

// Here we are in the "native" context
open();
$(accessibilityId("URL input field")).setValue("www.google.com");
$(accessibilityId("Go To Site button")).click();

// Oops, and we're already in the "web" context:
switchTo().context("WEBVIEW_com.saucelabs.mydemoapp.rn");
$("#i-am-not-a-robot").click();

assertThat(getContextHandles()).hasSize(2)

See PR 2308.
Thanks to Amuthan Sakthivel for PR 149.

Refactoring of CollectionCondition

We have changed the internal structure of collection conditions (class CollectionCondition).

If you wanted to create a custom collection condition, You had to implement method test(elements):

var allTextsStartingWithZ = new CollectionCondition() {
  public boolean test(List<WebElement> webElements) {
    return webElements.stream()
      .map(webElement -> webElement.getText().startsWith("Z"))
      .reduce(true, (x, y) -> x && y);
  }
}
$$(".moron").shouldHave(allTextsStartingWithZ)

This test method will stay for some time (for backward compatibility), but the recommended method now will be check(CollectionSource collection):

var allTextsStartingWithZ = new CollectionCondition() {
  public CheckResult check(CollectionSource collection) {
    List<WebElement> elements = collection.getElements();
    List<String> actualTexts = ElementsCollection.texts(elements);

    boolean allMatched = webElements.stream()
      .map(webElement -> webElement.getText().startsWith("Z"))
      .reduce(true, (x, y) -> x && y);
    return new CheckResult(allMatched, actualTexts);
  }
}
$$(".moron").shouldHave(allTextsStartingWithZ)

What does it give us?

In the future, it will open up opportunities for us to improve collection checks:

It allows us to greatly speed up the checks: for example, quickly get the texts of all elements with just one JS call.
In the error message, we can write “actual texts at the moment of last check” instead of “actual texts at the moment of error message generation”. The same problem for a single element was described here. Now it’s the same for collections.

See PR 2312 and PR 2307.

News

Video Testing Spring with Selenide by kanezi
Video series on Testing Mini Bytes: Selenide + Allure = Beautiful HTML Reports
Post Why we chose Selenide over Selenium by Amuthan Sakthivel
A historical moment: the first meme about Selenide

Andrei Solntsev

selenide.org

Released Selenide 6.14.0

2023-05-08T00:00:00+00:00

Good evening!

Good news: we have released Selenide 6.14.0.

It contains some changes that look minor, but might break something in your tests. That’s why I highly recommend to upgrade now

Sped up debugging
Removed flag --no-sandbox
Added method step for reports
Added method $.dragAndDrop(DragAndDropOptions)
Browser out of screen
Updated dependencies
News
Statistics

Speed up debugging

When you are debugging a test and stop at a breakpoint, sometimes IDE is rendering very slowly page object fields. In this state IDE can hang for quite a long time:

The reason is that Selenide makes multiple webdriver calls trying to get elements’ tag names, texts and attributes. As a result, you will see the most actual detailed information after some time:

Now this process will be significantly faster. Selenide will not call webdriver anymore, but just show locator:

But be informed that format of $.toString() / $$.toString() will change. Who knows, probably it might break your tests.

See issue 2253. and PR 2269.

But don’t worry, it’s all only about debugging. In case of test failure, you will still receive the full element information with blackjack and screenshooters.

Removed Chrome argument `--no-sandbox`

I personally don’t see any difference, whether I run tests with or without this argument.

But

Some users complain that Chrome cannot start in Docker without argument --no-sandbox;
Other users complain that Chrome, when started with argument --no-sandbox, doesn’t stop - and chrome process hangs forever in background and eats CPU. But it seems to happen only on Windows (?)

After years of hesitations, we decided to remove this argument --no-sandbox by default. Users of type #1

can easily detect the problem (chrome wont start)

can easily add this argument in their tests:

Configuration.browserCapabilities = 
  new ChromeOptions().addArguments("--no-sandbox");

See issue 2270 and PR 2271.

Added method `step` for reports

If you use Selenide built-in report (TextReport), now you can group actions using new method step:

@Test
void authentication() {
  step("login",()->{
    open("/login.asp");
    $("#username").val("u");
    $("#password").val("p");
  });

  step("logout",()->{
    $("#logout").click();
    $("#goodBye").shouldHave(text("Good bye looser!"));
  });
}

These “steps” will be visually distinguished in the report:

+---------------+-----------------------------------------------+-------+------+
| Element       |Subject                                        |Status | ms.  |
+---------------+-----------------------------------------------+-------+------+
| login         |                                               |PASS   | 4000 |
|    open       | http://127.0.0.1:8080/my_account/account.html |PASS   | 2662 |
|    #username  | val "u"                                       |PASS   | 300  |
|    #password  | val "p"                                       |PASS   | 400  |
| logout        |                                               |PASS   | 1023 |
|    #logout    | click                                         |PASS   | 923  |
|    #goodBye   | should have text "Good bye looser!"           |PASS   | 100  |
+---------------+-----------------------------------------------+-------+------+

By the way, those steps can be embedded into each other.

See issue 2172. Thanks to Maksim @Au6ojlut for PR 2250.

Added method `$.dragAndDrop(DragAndDropOptions)` with options

Now method $.dragAndDrop acquired a more logical sound: first “what”, then “where” and finally, “how”.

$("#drag1").dragAndDrop(to("#div2"));
$("#drag1").dragAndDrop(to("#div2").usingJS());

Thanks to Maksim @Au6ojlut for PR 2245.

Allow to set browser position out of screen

We fixed a minor bug that didn’t allow setting negative values to browser position:

Configuration.browserPosition = "-1900x-450";

I have no idea why this might be useful, but now it’s possible.

See issue 2258 and PR 2259.

Allow setting path to Edge browser binary

Selenide has setting Configuration.browserBinary that allows you set path to browser binary (just in case: in most cases, you don’t need to set it).

Previously, this setting was not supported for Edge browser. Now it’s supported.

Thanks to Vladislav Velichko for PR 2267.

Updated dependencies

Selenium 4.9.1 - see changelog
Netty 4.1.92.Final

News

Series of tutorials Selenide Java with Cucumber by TechPro Education

Statistics

Number of monthly downloads of Selenide exceeded 600 thousands!

Andrei Solntsev

selenide.org

Released Selenide 6.13.0

2023-04-04T00:00:00+00:00

Good night!

Today we have a big major release Selenide 6.13.0.

Added method $.cached()
Added http status for server response mock
Added method inNewBrowser for running code in a new browser
Added method $.doubleClick(options)
Added condition $.shouldHave(innerText())
Added collection condition $$.shouldHave(attributes(...))
Clear error message in methods $.select*()
Fixed bug in $$.subList()
Updated dependencies
News

Added method `$.cached()`

Sometimes you need to write quite complex code for finding an element.
And it might work slowly, especially if you find it from a long collection applying specific filtering.
Something like this:

ElementsCollection subscriptions = $$("div.subs-expands")
  .filter(childExactText(
     By.xpath(".//div[contains(@class,'data')]//div[contains(@class,'heading')]"),
     orderNumber)
  );

SelenideElement target = subscriptions
  .filter(childAttributeValue(...))
  .find(childExactText(....));

Every call to target is apparently slow.

Now you can speed up such tests by caching the target element:

SelenideElement target = subscriptions
  .filter(..)
  .find(..)
  .cached();

Obviously, you can cache it only if you are sure that it’s not updated/reloaded during the test.
If it still gets reloaded, you will get the famous StaleElementReferenceException.

See issue 2171, issue 1927 and PR 2189.

Added http status to server response mock

Selenide has method for mocking a server response:

getSelenideProxy().responseMocker().mockText("login-mock", 
          urlContains(POST, "/login"), () -> "{role: admin}");

It allowed to mock only response body, response status was always 200 (“OK”).
Now you can set another status too:

getSelenideProxy().responseMocker().mockText("login-mock", 
          urlContains(POST, "/login"), 403, () -> "{role: looser}");

See issue 2227 and PR 2234.

Added method `inNewBrowser` for running a code snippet in a new browser

Sometimes you want to run a code block in a new browser.

Usually I say it’s a bad practice. Actions like data preparation etc. should not be performed via UI (we are testing UI -> we cannot trust UI). Instead, you should use some reliable way: using API, query to database etc.

Still, for this purpose we have method using. But to use it, you need to open your custom webdriver with some specific settings. But what if you don’t specific settings? What if you need a standard webdriver with usual Selenide settings - just a new instance of browser?

Now you can use method inNewBrowser for that:

open("https://site.com/login/as/user/bob");

inNewBrowser(() -> {
  open("https://site.com/login/as/admin");
  $(by("value", "bob")).find("[name=is_admin]").setEnabled();
});

$("h1").shouldHave(text("Hello, chat admin!"));

See issue 2213 and PR 2236.

Added method `$.doubleClick(options)`

We already had method $.doubleClick() which could only click the center of given element. Now it got an advanced bro with options parameter. The options are the same as for usual $.click method:

$(".btn").doubleClick(usingDefaultMethod());
$(".btn").doubleClick(usingJavaScript());
$(".btn").doubleClick(usingDefaultMethod().offset(66, 33));
$(".btn").doubleClick(usingJavaScript().offset(66, 33).withTimeout(ofSeconds(9)));

See issue 2133. Thanks to aakachurin for PR 2135.

Added condition `$.shouldHave(innerText())`

It allows to check texts of hidden elements.

Probably it’s a bad idea: if real users cannot see the element then you don’t need to test it.

But if you really want, you can now use condition innerText:

$("#theHiddenElement")
  .shouldHave(innerText("Can you see the hidden text?"));
  // Usual $("#theHiddenElement").text() returns an empty string here: "";

See issue 2220 and PR 2223.

Added collection condition `$$.shouldHave(attributes(...))`

$$("#numbers option").shouldHave(attributes("value",
                "one", "two", "three", "four", "five"));

See issue 2091. Thanks to Alexey Lakovych for PR 2091. See also PR 2230.

Added a clear error message in methods `$.select*()`

Selenide has convenient methods for working with dropdowns:

$("select#gender").selectOptionContainingText("Female");

Recently we changed their implementation to JavaScript - it’s faster and stable.

But it turned out that if you mistakenly call such a method for a non-<select>, a very incomprehensible error took off:

$("ul").selectOptionContainingText("Kelly Snyder");
--> JavascriptException: 
      javascript error: 
        undefined is not iterable (cannot read property Symbol(Symbol.iterator))

Now this error message will be clear:

IllegalArgumentException: Cannot select option from a non-select element

See issue 2231 and PR 2233.

Fixed bug in method `$$.subList()`

As you know, Selenide has methods for checking the whole collection of elements with one line:

  $$("#numbers").shouldHave(texts("One", "Two", "Three", "Four", "Five"));

Method $$ returns an object ElementsCollection, which (unfortunately) is inherited from AbstractList<SelenideElement>. Thus, it inherits few unexpected methods that we initially didn’t think about.

One of such methods is subList:

  $$(".user").subList(1, 4).iterator();

This iterator returns two, not three elements. It truncates the last element. Oops… ¯\_(ツ)_/¯

Now this bug is fixed. Iterator will return all elements.

See issue 2239 and PR 2240.

Updated dependencies

bump Selenium from 4.8.1 to 4.8.3 – see CHANGELOG
bump LittleProxy from 2.0.16 to 2.0.17
bump BrowserUpProxy from 2.2.8 to 2.2.9
bump nettyVersion from 4.1.90.Final to 4.1.91.Final

News

Today we have few videos about Selenide

ChatGPT: How to download file in Selenide
Flaky tests
Selenide channel by NaveenAutomationLabs

Andrei Solntsev

selenide.org

Released Selenide 6.13.0

2023-04-01T00:00:00+00:00

Hi all!

Wow, today we released Selenide 6.13.0

Banners support
News

Banners support

The problem

People often asked me: “What can I do if during a test execution, a banner can appear on the screen (or any other unexpected element)?”

Such a banner can cover other elements, can hide some important button - and your test might occasionally get broken.

I’ve always scolded these questions and insisted that you should control your testing environment. You should dictate when the banner should appear, and when it should not.

But this question was too popular. In the end, we decided to suggest a solution in Selenide.

Now you can all new method Selenide.onBanner() in the beginning of your test:

onBanner("#pizzaAds", CLOSE, ".btn-close");

How it works

By default, this method adds a listener to webdriver. Before every click or check, this listener will ask browser if there exists an element with given selector "#pizzaAds". If it exists, Selenide will try to close it by clicking button ".btn-close".

We called this method POLL. It’s very simple and stable, but it’s also relatively slow. Because Selenide needs to ask from browser many-many times if the banner has appeared. Every request takes some time.

Alternative methods

That’s why we added 2 alternative methods for checking if the banner exists. You can enable them by a global setting:

Configuration.bannerCloseMode = POLL; // the default mode

// Listens DOM change events via CDP:
Configuration.bannerCloseMode = CDP; // Works only in Chromium-based browsers

// Sends current page html to ChatGPT and asks if it contains a banner
Configuration.bannerCloseMode = CHATGPT; 

Or you can set mode as a parameter using using:

onBanner(using(CDP)
  .withBannerSelector("#pizzaAds")
  .withCloseButtonSelector(".btn-close")
  .withAction(CLOSE)
);

Custom logic

There is a more generic option if you need to implement some custom logic for handling banner. For example, you might need to find some info inside the banner before closing it:

onBanner(using(CHATGPT)
  .withBannerSelector("#pizzaAds")
  .withCloseButtonSelector(".btn-close")
  .withAction((banner, closeButton) -> {
     banner.find(".title").shouldHave(text("Your password has been changed."));
     String newPassword = banner.find(".new-password").text();
     closeButton.doubleClick();
   })
);

Feel free to try, experiment, register issues on GitHub. Feel free to suggest your algorithms for banner detection.

Let’s unite against banners!

News

Today we have few video about Selenide:

ChatGPT: How to download file in Selenide
Channel Selenide - UI Automation Tool by Naveen AutomationLabs
Flaky tests - JFokus conference, Stockholm, 8.02.2023

Andrei Solntsev

selenide.org

Released Selenide 6.12.4

2023-03-23T00:00:00+00:00

Good evening!

We released Selenide 6.12.4.

Workaround for Chromedriver
Support for jdk-http-client
Fixed $.download(PROXY) after “using”
Fixed $.clear() when element disappears
Updated dependencies
Released selenide-appium 2.7.0
Released selenide-selenoid 2.3.6
News

Workaround for Chromedriver

Reminder: if you still are looking for a solution for

Invalid Status code=403 text=Forbidden

then it was released in Selenide 6.12.2.

Added support for `jdk-http-client` as a replacement for `netty-client`

By default, Selenide still uses old good netty-client, but if you wish to
upgrade to jdk-http-client, now you can easily do that:

Add dependency:
org.seleniumhq.selenium:selenium-http-jdk-client:$seleniumVersion
Add system property before opening a browser:
System.setProperty("webdriver.http.factory", "jdk-http-client");

See issue 2215 and PR 2216.

Restored proxy after using `using`

It’s almost the same problem as issue 2202, but with Selenide built-in proxy.

If you enabled a proxy in your tests, once you used method using, the proxy disappeared. The following downloading of files (or any other featured you used proxy for) didn’t work anymore.

Now using method has been fixed. See more details about this very convenient method using.

See PR 2208 and PR 2209.

Fixed `$.clear()` when element disappears

As you know, Selenide has method $("input").clear() that clears given input field.
But it could fail in one specific situation: when the input disappears as a result of clearing.
At this moment, method $.clear() tried to trigger change event on this input - and failed.

See issue 2207 and PR 2221.

Updated dependencies

#2210 Bump nettyVersion from 4.1.89.Final to 4.1.90.Final
#2218 Bump slf4jVersion from 2.0.6 to 2.0.7

Released `selenide-appium:2.7.0`

Added scroll up/down for mobile apps (#139)
Fixed method terminateApp (#146)
Upgraded to Selenide 6.12.4 (#143)

See release notes.

Released `selenide-selenoid:2.3.6`

Upgraded to Selenide 6.12.4

See release notes.

News

Finally, I have a video about Flaky tests in English - JFokus conference, Stockholm, 8.02.2023

Andrei Solntsev

selenide.org

Released Selenide 6.12.2

2023-03-09T00:00:00+00:00

Hi all!

Urgently update to Selenide 6.12.2!

It has one important workaround for Chromedriver 111 issue:

Invalid Status code=403 text=Forbidden

What’s the problem?

Recently a new version of Chrome and Chromedriver was released: 111.

People who did upgrade their browser unexpectedly started getting test failures.
Test tried to open the browser. The browser window appeared, but webdriver received an exception, and could not do any following actions. In the end, test could not even close that browser!

In logs, you could read only messages like this:

Starting ChromeDriver 111.0.5563.64 on port 31021
org.openqa.selenium.remote.http.WebSocket$Listener onError
WARNING: Invalid Status code=403 text=Forbidden
java.io.IOException: Invalid Status code=403 text=Forbidden
...

Although it’s a bug in chromedriver, it had a simple workaround, and we decided to add it to Selenide to avoid a bigger hassle in QA world.

See issue 2192 and PR 2194.

We recommend you upgrading to HttpClient. Yes, it requires Java11+, but has better support etc.

Andrei Solntsev

selenide.org

Released Selenide 6.12.0

2023-02-24T00:00:00+00:00

Hello!

On this tragic and festive day, we released Selenide 6.12.0.

It doesn’t contain any new features, but it introduces new headless mode that might affect your tests.

New headless mode

In Chromium browsers, a “new headless” mode has been recently introduced. Read more details in their blog.

Shortly said, it’s a better headless mode that should fix all problems of the “old headless”.

In theory, you can still switch between the old and new headless modes. But in practice, you will have to switch to a new one. Because after last Chrome and Edge update, downloading files in the old headless mode stopped working.

Starting from Selenide 6.12.0, the new headless mode will be enabled by default.

See issue 2104. Thanks to Boris Osipov for PR 2105 and PR 2169.

Improve logging when downloading files

If file downloading failed (especially using method FOLDER), it’s sometimes hard to understand why it failed.
Now we improved logging inside of method $.download(), so the debugging should become easier.

See PR 2167.

Improved downloading files in Edge on Windows

When downloading a file in Edge browser, Selenide tracks temporary files “.crdownload”. They are created by Chromium engine during the download process. Recently we realized that on Windows, Edge also creates temporary files “.tmp”. Now Selenide tracks them too.

See PR 2167.

Updated dependencies

bump Selenium from 4.8.0 to 4.8.1, see PR 2161 and Selenium release notes.
Bump nettyVersion from 4.1.87.Final to 4.1.89.Final, see PR 2158.

Renamed `master` branch to `main`

Yes, these are echoes of that same BLM. One smart person convinced me that it’s worth to rename the branch. :)

News

Post Test automation framework for UI testing with java by Oleksandr Podoliako
Post Running test automation with Selenide on GitLab by Pradap Pandiyan
My video from Continuous Testing Meetup: Selenide UI tests in java, 23.01.2023

Well, why did I call this day festive? It’s because February, 24 is actually the Independence Day of Estonia. 105 years ago, Estonian troops expelled the invaders from the country and proclaimed a new independent state.

Without that brave guys on the armored train, there would be no Selenide now. :)

UPD Released Selenide 6.12.1

Fixed an old bug in method using.

See changelog

UPD Released Selenide 6.12.2

Added a quick workaround for Chromedriver 111 issue:
Invalid Status code=403 text=Forbidden.

See changelog

UPD Released Selenide 6.12.3

We fixed one old bug in method $.download(FOLDER) (if it’s called after using).

See changelog

Andrei Solntsev

selenide.org

Released Selenide 6.11.1

2023-01-20T00:00:00+00:00

Good jan!

We release a minor update Selenide 6.11.1.

Truncate only `WebDriverException` messages

In a very rare situation - if you

declare a custom command,
throw some assertion error from it,
and this error has multi-line message,

then Selenide truncates this error message, leaving only the first line.

Initially, our intention was only to truncate error message of WebDriverException because it contains multiline garbage:

The element could not be found (WARNING: The server did not provide any stacktrace information) Command duration or timeout: 21 milliseconds For documentation on this error … Build info: version: ‘2.29.1’, … System info: os.name: ‘Linux’, … Session ID: 610138404f5c18… Driver info: org.openqa.selenium.chrome.ChromeDriver

But here the mistake comes: Selenide truncated message not only for WebDriverException, but for all errors. Now we fixed it, and you will see your multiline goodness entirely.

See PR 2131.

Fixed `$.download(FOLDER)` a bit

This is a very rare case, so you probably didn’t even notice it.

But our tests flaked sometimes, so I had to start investigation. And found couple of rare bugs in $.download(FOLDER). Sometimes it could report that the file is not downloaded (though it was) in two cases:

#2116 If the file’s modification timestamp appeared in the previous second of click (it may happen because different file systems may return file modification time with error up to 1 second. And it can be even in the past.)
#2119 If the file’s modification timestamp was “0” (according to the spec, it may happen if for some reason file system decided that the path is invalid)

Now it should continue downloading in both cases.

Updated dependencies

bump WebdriverManager from 5.3.1 to 5.3.2
bump Netty from 4.1.86.Final to 4.1.87.Final, see PR 2126.

News

Post by Amuthan Sakthivel Why we chose Selenide over Selenium for our Test Automation Needs

Statistics

Number of monthly downloads of Selenide exceeded 490 thousands!

To be continued…

Andrei Solntsev

selenide.org

Released Selenide 6.11.0

2023-01-03T00:00:00+00:00

Happy New Year, dear friends!

Santa Claus brought us a new release Selenide 6.11.0.

Added methods to copy and paste text

We added two methods:

Selenide.copy() for copying currently selected text to clipboard, and
$.paste() to paste clipboard content into input field.

open("https://best-propaganda-quotes.ru");
$("#solovjov").doubleClick(); // select the quote text
Selenide.copy();
$("[name=q]").paste();
$("[name=q]").shouldHave(text("Life is highly overrated"));

Known restrictions: these methods need a graphics environment. So they would not work on server linux. But simple running xvfb should help.

See issue 1817.
Thanks to Evgenii Plugatar for PR 2027.

Fixed method `Selenide.download(url)`

…in case if url contains login/password (the resource is protected by BasicAuth).

For example, this code worked few weeks ago, but stopped working after upgrading Apache Http client (internally used by Selenide):

File f = Selenide.download("https://admin:tiger@the-internet.herokuapp.com/basic_auth");

In the latest update, Apache Http client enforced URL validation, and this part with login/password is not allowed anymore (it’s kinda unsafe deprecated way of passing credentials).

Now Selenide removes credentials from url and sends them with http header Authorization.

See issue 2037 and PR 2102.

Now Selenide allows downloading large files via proxy

If you use PROXY method for downloading files, you might know that file size could not exceed 64 megabytes.
Initially, it seemed a reasonable limit: why should anyone need to load a test bench by downloading giant files? (even 64 mb was quite big: BrowserUpProxy by default sets limit to 2 megabytes; we increased it to 64 in Selenide)

But it turned out that sometimes people want to test downloading large files. After a discussion, we decided to simply remove this limit. You decide if you want to load your test environment.

File favoriteMovie = $("#topMovie").download();
assertThat(favoriteMovie)
  .hasName("BadSanta.avi")
  .as("2 GB").hasSize(2147483648L);

P.S. Be aware that proxy might not quickly download files that are too large. And BrowserUpProxy still has built-in technical restriction of 2 gigabytes (because of Integer type used for file size limit).

But at least now you can download, say, 200 megabyte files.

See issue 2082 and PR 2098.

Now you can handle unexpected alerts

By default, Selenide ignores unexpected alerts in browser. (More specifically, Selenide runs webdriver with option capabilities.setCapability(UNHANDLED_PROMPT_BEHAVIOUR, ACCEPT)).

On the one hand, this is convenient so that tests do not break due to sudden pop-up ads and other useless messages. On the other hand, sometimes these alerts can contain useful information - in particular, a valuable error message.

If this is your case, now you can override this option:

import static org.openqa.selenium.remote.CapabilityType.UNHANDLED_PROMPT_BEHAVIOUR;
import static org.openqa.selenium.UnexpectedAlertBehaviour.ACCEPT_AND_NOTIFY;

Configuration.browserCapabilities.setCapability(UNHANDLED_PROMPT_BEHAVIOUR, ACCEPT_AND_NOTIFY);

Then you will get an exception saying what message that alert contained:

UnhandledAlertException: unexpected alert open: {Alert text : Oops} // chrome
UnhandledAlertException: Accepted user prompt dialog: Oops: // firefox
UnhandledAlertException: unexpected alert open: {Alert text : Oops}  // edge
UnhandledAlertException: : Oops // safari

See issue 2054 and PR 2095.

Fixed permissions for screenshot file

When your test fails, Selenide automatically takes a snapshot of current page, thus creating two files: : *.png and *.html. It turned out that these files had different permissions:

-rw------- 1 root root 300295 Dec 19 10:24 1671441847908.0.png
-rw-r--r-- 1 root root 185070 Dec 19 10:24 1671441847908.0.html

And it caused difficulties for some advanced devops how wanted to run different step of build pipeline by different users. Whatever devops amuses… :)

Now both files have the same permissions: -rw-r--r--.

See issue 2081 and PR 2084.

Support `@As` annotation for fields without `@FindBy`

In Selenide, you can give readable names (aka “aliases”) for page object fields with method as:

class LoginPage {
  SelenideElement loginButton = $(By.xpath("/long/ugly/xpath[3]")).as("Login button");
}

But there was an idea that it would be convenient to put the name at the beginning of the line. Otherwise, it would be visually lost on the right of the long selector.

Now you can give alias with annotation @As:

class LoginPage {
  @As("Login button")
  SelenideElement loginButton = $(By.xpath("/long/ugly/xpath[3]"));
}

But of course, the annotation will work only if you initialize the page object with method Selenide.page() or Selenide.open().

See issue 2087 and PR 2088.

Added methods to get last saved page source

It’s rarely needed, so don’t bother. Essentially, we added few methods to class ScreenShotLaboratory: threadScreenshots(), contextScreenshots(), lastThreadScreenshot(), lastContextScreenshot().

Thanks to Arman Ayvazyan for PR 2065.

Now you can add page URL to error message

Sometimes it might be useful, sometimes harmful. After a discussion, we decided to make this feature optional (in a form of a plugin).

Let it stay in experimental status for now. We will probably play with error message formats in the future.

See issue 980 and PR 2097.

Year summary

Let’s sum up year 2022? During this year, Selenide was mentioned in several ratings:

5 Testing Automation Tools in Qameta Software blog
Top Java Libraries for Automation Testing in 2022
Top Java Frameworks to Use in 2022

and finally,

Selenide got mentioned on Selenium official site in category “Ecosystem”.

Selenide monthly downloads statistics grew by half:

from 302 thousands in January
to 469 thousands in November.

And still

It’s been a terrible year.

I hope that in the coming year the war will end, the guilty will be punished, the citizens of the oppressed countries will finally overthrow their tyrants.

And the beautiful free country of Ukraine will be rebuilt and will bloom more than ever.

And after a year, we will see you in Kyiv at the wonderful SeleniumCamp conference.

Glory to the heroes!

Andrei Solntsev

selenide.org

Released Selenide 6.10.2

2022-12-08T00:00:00+00:00

Good evening!

We got mini-release Selenide 6.10.2.

Added method `$.press()`

It’s essentially the same ss sendKeys(), but it’s not void. You can chain it with other methods:

$("#username")
  .press("x")
  .press(TAB, CONTROL, ALT, ENTER)
  .should(disappear);

Thanks to Amuthan Sakthivel for PR 2032.

Trigger `change` event by method `$.select*`

As you remember, in previous release we reworked working with selects using JavaScript. But we forgot to trigger focus, click and change events. Now we trigger them.

See issue 2050. Thanks to Vicente Rossello Jaume for PR 2051.

UPD. Fixed once again in Selenide 6.10.3.

Show `$.selectOption()` friendly in reports

Another minor issue caused by the refactoring of selects: these operations look ugly in reports.
That’s because Java arrays don’t have standard method toString(), and developers have to re-invent the wheel.

Before:

| #blockChannel     | select option([TV Rain, [Ljava.lang.String;@6732726])     | PASS       | 487        |

After:

| #blockChannel     | select option(TV Rain)     | PASS       | 487        |

See issue 2047 and PR 2052.

Show `localStorage` friendly in reports

Similar problem with sessionStorage and localStorage: they look unreadable in reports.

Before:

| com.codeborne.selenide.LocalStorage@138a952f    | set item(['Bout', 9125])     |
| com.codeborne.selenide.SessionStorage@549w123gg | set item(['Griner', 3285]) |

After:

| localStorage            | set item(['Bout', 9125])      |
| sessionStorage          | set item(['Griner', 3285])  |

See issue 2045 and PR 2046.

Upgraded dependencies

#2044 #2057 bump Selenium from 4.6.0 to 4.7.1
#2036 bump browserup-proxy-core from 2.2.5 to 2.2.6
#2058 bump httpclient5 from 5.2 to 5.2.1
bump slf4j from 2.0.4 to 2.0.5

Subprojects

We also released our subprojects:

News

Selenide Tutorial: Replacement for Selenium? on Testing Mini Bytes channel
Test automation framework for UI testing with java by Oleksandr Podoliako

Andrei Solntsev

selenide.org

Released Selenide 6.10.0

2022-11-21T00:00:00+00:00

Evil evening!

We released Selenide 6.10.0.

Improved file download algorithm

Selenide contains several algorithms for downloading files: HTTPGET, PROXY and FOLDER. Let’s talk about FOLDER. To download a file, it clicks the button and waits for new files in downloads folder.

File racoons = $("#stolenRaccoonsReport").download(using(FOLDER));
assertThat(racoons).hasName("racoons.xls");

The problem is that it didn’t work well in Firefox in case of very slow download. We realized that Firefox creates immediately two files: “racoons.xls” and “racoons.xls.part” - both are empty. And only then starts filling “racoons.xls.part”.

Now the FOLDER algorithm is smarter. It

waits until some suitable file appears in the downloads folder;
waits until all *part files disappear (in Firefox);
waits until all *crdownload (in Chrome);
waits until none of files has been modified for 1+ seconds (in other browsers).

This approach should provide more reliable file downloads.

See issue 1989 and PR 2003.

Fail fast the downloading process if no progress observed

People often set a long timeout for downloading files. Especially when downloading a large file:

File video = $("#skaebova").download(using(FOLDER)
  .withTimeout(Duration.ofSeconds(99))
  .withName("puten mobshiza.MP4"));

But it doesn’t make sense so long if the downloading process has not even started. For example, if the click missed the button (how it can happen, I showed in video “Flaky tests”).

To fail earlier, you can set another parameter “increment timeout”:

File video = $("#skaebova").download(using(FOLDER)
  .withTimeout(ofSeconds(99))
  .withIncrementTimeout(ofSeconds(2))
  .withName("puten mobshiza.MP4"));

In this case, the general download timeout is 99 seconds, BUT it during 2 seconds none of files is modified, then the method will throw an exception immediately.

See issue 1990 and PR 2023.

Select `<select>` options using JavaScript

It should made work with <select>s faster. As a bonus, now Selenide throws a more detailed exception if <select> (or <option>) was disabled.

Given a <select> with some disabled options:

<select id="region">
  <option value="belgorod">Belgorod</option>
  <option value="kherson" disabled>Kherson</option>
  <option value="zaporozhia" disabled>Zaporozhia</option>
</select>

Trying to select a disabled option:

$("#region").selectOption("Kherson");

will throw a clear error message:

Invalid element state [#region/option[text:Kherson]]: Cannot select a disabled option

Before this release, the error was not so detailed:

java.lang.UnsupportedOperationException: You may not select a disabled option

(and even earlier, such a test did not fall at all, but did not select the option either)

See issue 1553 and PR 1876.

Specials thanks to Oleg Berezhnoy for PR 1553. Though it was not merged, it triggered a discussion in Selenide and even in Selenium team: what is a “just framework” and “opinionated framework”.

Made `$.click(options)` chainable

People often complain that method $.click() has return type void. You cannot chain it like this:

  $(".btn").click().should(disappear);

Alas, we cannot fix it, since class SelenideElement inherits method void click() from Selenium’s WebElement.

But we made chainable another (overloaded) click method (the one with parameters).
At least this one can now be chained:

  $(".btn")
    .click(usingDefaultMethod())
    .should(disappear);

  $(".btn")
    .click(usingDefaultMethod().withOffset(42, 42))
    .shouldHave(cssClass("alert"));

See issue 2007 and PR 2008.

Fixed window size of new tabs

Thanks to Boris Osipov for PR 2017.

P.S. Fixed once again in Selenide 6.10.1

Support BasicAuth login/password with special characters

Selenide can open sites protected by BasicAuth:

open("/basic-auth/hello", BASIC, 
  new BasicAuthCredentials("", "Královec", "is Czechia /:)"));

This login/password is added either to http header Authorization (if proxy is enabled) or URL (if proxy is disabled).

Recently I discovered that the the second way doesn’t work correctly if login or password contains special characters. When adding to URL, these characters were not escaped, causing an invalid URL:

https://Královec:is Czechia /:)@127.0.0.1:4405/basic-auth/hello

browser could not open such a link.

I am curious, why nobody every complained about that? Do you all use just scott/tiger credentials? :)

Now Selenide encodes such characters and generates a valid URL:

https://Kr%C3%A1lovec:is+Czechia+%2F%3A%29@127.0.0.1:27663/basic-auth/hello

See issue 2020 and PR 2021.

Upgraded dependencies

Selenium from 4.5.0 to 4.6.0, see changelog
WebDriverManager from 5.3.0 to 5.3.1, see changelog
BrowserUpProxy from 2.2.3 to 2.2.5, see changelog
Netty from 4.1.82.Final to 4.1.85.Final
LittleProxy from 2.0.13 to 2.0.14, see changelog
#2014 Bump httpclient5 from 5.1.3 to 5.2, see PR 2014
#2025 bump slf4j from 2.0.3 to 2.0.4, see PR 2025

Child projects

We also released our child projects:

News

JetBrains released AQUA - new IDE for automated tests! Nice logo!
Selenium introduced its own built-in WebDriverManager analogue. Someone already tried it?
New framework Selenide Pages based on Selenide from Maxim Kochetkov. Nice logo!

Videos and posts

Post All About Selenide by Muhammad Naeem
Video Working with web elements using Selenide by Automation Bro
Post Page Object Model from “Selenide Tutorial Series” by Automation Bro

Statistics

Our Selenide user group in LinkedIn has already 176 members. Join!
We got a fresh downloads statistics for October. We passed the 470 thousands line!

Andrei Solntsev

selenide.org

Released Selenide 6.9.0

2022-10-07T00:00:00+00:00

Yo Seleniders!

Let me break your doomscrolling with some good news.

We released Selenide 6.9.0! Basically, they pumped proxies and updated selenium.

Now Selenide proxy can mock server response

As you know, Selenide can run its own embedded proxy server. It listens requests between browser and other world. We mostly used it in read-only mode (logging, downloading files). But now you can also change the traffic. Namely, you can replace server response. It may be useful to mock the response of some service.

Let’s look at some simple abstract example.

Example

Let’s say you’re testing a site showing the results of a referendum. It’s a html page on address, say, https://referendum.ru, which calls service https://cik.ru to fetch json with voting results.

Since the results are not known in advance, but the site needs to be tested here and now, we want to check how it will look in different corner cases.

Test

open();
getSelenideProxy().responseMocker().mockText("cik-mock",
    urlStartsWith(GET, "https://cik.ru/api/gov/no/referendum"), 
    () -> "{votes: 2133326, for: 99.23, against: 0.77}");

open("https://referendum.ru");
$("#votesFor").shouldHave(text("99.23%"));
$("#h3").shouldHave(text("not only satisfy but also surprised"));

Explanation

Look at the first parameter cik-mock. This is name of the mock.
You can use it later to cancel the mock (to avoid occasional effects on the following tests):

@AfterEach
void tearDown() {
  getSelenideProxy().responseMocker().reset("cik-mock");
}

Or you can just cancel all the mocks for safety:

@AfterEach
void tearDown() {
  getSelenideProxy().responseMocker().resetAll();
}

Constraints

If you site and mocked service run on same domain, there is no constraints.
But if the site calls a service on another domain, mock will work only if

both site and mock run on https (not http)
service is alive and accessible from proxy

In sum

Using mocks is a powerful technique letting us verify different corner cases that are hard or even impossible to reproduce otherwise
(“146% votes for”, “no one showed up to vote”, “service is unavailable” etc.)

Do not be shy about your desire to correct, clean up, add something. It will work as you want.

See issue 1254 and PR 1978.

Send authorization header only to specified domain

Some site you need to test are protected by BasicAuth. Selenide allows to open such sites with overloaded method open:

open("https://referendum.ru/admin", BASIC, 
             new BasicAuthCredentials("saver-of-the-world", "gojda!!!"));

This method can overcome BasicAuth:

if proxy is not enabled - by adding login/password to URL,
and if proxy is enabled - by adding http header Authorization to requests from browser to server.

But here’s the problem. Recently we realized that Selenide sent Authorization header not only to the app under test, but also to all other services (e.g. S3 or Google authentication).

Now Selenide will send Authorization only to needed domain. But you will also need to specify the domain in constructor:

open("https://referendum.ru/admin", BASIC, 
             new BasicAuthCredentials("referendum.ru", "saver-of-the-world", "gojda!!!"));

See issue 1974 and PR 1975.

Improved resolving proxy host name

When you enable proxy in Selenide (e.g. by setting Configuration.proxyEnabled = true), it will run embedded proxy server on random port. And open a browser with instructions to use proxy HOST:PORT. The question is, which HOST to use?

Until now, we used expression ClientUtil.getConnectableAddress() to resolve the host name (it’s default behaviour of BrowserUpProxy). But from this release, we will use new NetworkUtils().getNonLoopbackAddressOfThisMachine() (it’s Selenium internal method). I’m too lazy to figure out what their specifics are, but they may return different results on my machine:

new NetworkUtils().getNonLoopbackAddressOfThisMachine() -> 192.168.0.18
ClientUtil.getConnectableAddress() -> 127.0.0.1

The first one is definitely better when the browser runs on different machine or in a container. The proxy will just not be accessible by address 127.0.0.1 from other machine.

If none expression works properly for you, you can always specify host name explicitly by setting Configuration.proxyHost = "my.comp.eu";

See PR 1970.

Upgraded to Selenium 4.5.0

Notable changes:

dropped support for Opera browser
added alternative implementation of webdriver transport using JDK 11 HTTP client instead of Netty client
added checks for disabled in class Select (now you cannot select a disabled options anymore)
removed host name from Selenium exceptions

arrr, I asked for this change since 2015!!!

See changelog and PR 1967.

Removed support for Opera browser

As a consequence of the Selenium upgrade, we also had to drop Opera support. I guess the reason is that Opera uses Chrome engine and is not very different from Chrome. If you still need to run tests in Opera - it’s possible, just use chromedriver.

See PR 1967.

Removed `getAlias` from reports

Thanks to Reserved Word for PR 1971.

Restored setting “connection timeout”

Few people need this, so feel free to skip it.

We used to have two settings for the webdriver http client: “connection timeout” and “read timeout”. The first one had to be removed when upgrading to Selenium 4, because it was cut out there. Now it was resuscitated in Selenium 4.5.0, well, so we resuscitated also.

See PR 1977.

Upgraded dependencies

LittleProxy from 2.0.12 to 2.0.13
slf4j from 2.0.2 to 2.0.3

Not only IT people suffer from constantly changing requirements!

Andrei Solntsev

selenide.org

Released Selenide 6.8.1

2022-09-27T00:00:00+00:00

Gooda!

Catch min-bugfix Selenide 6.8.1.

This only applies to those who directly call in their tests

new RemoteWebDriver(url, options)

and encountered NoClassDefFoundError after upgrading to Selenide 6.8.0.

Prehistory

What is OpenTelemetry? This is some kind of thing that was added to Selenium 4 for some reason, but nobody really knows why it’s needed and how to use it. :) In fact, no one cares, no one uses it. :)

In Selenide, we also removed it in PR 1763.

OpenTelemetry dependency in Selenium is like Special Military Operation: nobody knows why it’s needed.

The problem

So, most Selenide users don’t have such a problem.

BUT you might into trouble if you call constructor new RemoteWebDriver(url, options) in your tests. Unfortunately, it requires OpenTelemetry dependency. And after upgrading to Selenide 6.8.0 these users might get NoClassDefFoundError.

Temporary solution

Add parameter false to the constructor: new RemoteWebDriver(url, options, false). This false says “please don’t user telemetry”.

Demobilized OpenTelemetry dependency

In short, we quickly released Selenide 6.8.1, which brought back OpenTelemetry.

See issue 1965 and PR 1966.

Andrei Solntsev

selenide.org

Released Selenide 6.8.0

2022-09-24T00:00:00+00:00

Bad morning!

While the world is going crazy, we are releasing Selenide 6.8.0.
Not so many features, rather dependency updates.

Recursive search in shadow dom

As you probably know, Selenide has methods to find elements inside shadow dom. And even in multiple embedded shadow doms:

$(shadowCss("#reportButton", 
     "#shadow-host", "#inner-shadow-host")).click();

But you still need to waste time to investigate these doms and find proper locators for all those shadow roots.

Now you can save time with the help of new method shadowDeepCss - it searches the element recursively in all shadow roots all over the dom.

$(shadowDeepCss("#reportButton")).click();

Naturally, there is still a risk that such “too generic” search can find a wrong element which probably resides in another shadow dom, but occasionally matches your locator.
In this case you will need to return to the old good “exact” search.

As in the case of databases and sausages, “it’s better not to look inside” - there is a bunch of tricky javascript for tree search.

See issue 1946.

Thanks to

Boris Osipov for PR 1947, and
Georgegriff for project query-selector-shadow-dom, from where we stole this code. :)

Added method `page()` not requiring `Class` argument

Dear Page Object fans, take a seat, this is for you. There is a turning point in your life.

Now you don’t need to pass Class argument to method page(Class pageObjectClass). Wow!

Instead of

SelectsPage page = page(SelectsPage.class);

you can just write

SelectsPage page = page();

I used to think Java couldn’t do that, but then I found a hack.

See PR 1961, and thanks to Tagir Valeev for the hack.

Added annotation `@As`

… for giving human-readable aliases for page object fields.

1. Without aliases

Assuming you have a page object with @FindBy annotations:

class PageObject {
  @FindBy(xpath="//table/div[3]/span[4]/h1")
  SelenideElement header;
}

and a test like page.header.shouldBe(visible).

In reports, it looks quite long and unreadable:

| open                                  | https://devclub.eu  | PASS  |
| By.xpath: //table/div[3]/span[4]/h1   | should be(visible)  | FAIL  |

And when the test fails, it’s quite hard to understand which element was not found:

Element not found {By.xpath: //table/div[3]/span[4]/h1}

People often want to give some human-readable names to elements to avoid seeing long ugly xpath’s in reports.

2. Resistance

I have always been against it. I believe that not only reports, but also the tests themselves should be readable. I stand for clean code. If you don’t like the ugly xpath - well, just change it, don’t hide it!

But still decided to meet people’s need. In Selenide 5.17.0, we added method $.as("alias").

3. With aliases

And in this release you can also add annotation @As to page object fields.

class PageObject {
  @As("Large header")
  @FindBy(tagName = "h1")
  SelenideElement header1;
}

It will look readable in reports:

| open    | https://devclub.eu   | PASS   |
| title   | should be(visible)   | FAIL   |

And when the test fails, it’s easier to understand which element was not found:

Element "title" not found {By.xpath: //table/div[3]/span[4]/h1}

See issue 1903 and PR 1956.

Don’t forget: everyone lies.

Documentation lies, comments lie, users lie. Sooner or later, the alias will also lie. Someone changed the locator, but forgot the alias. Or the element was copied, but the alias was forgotten to be changed. Etc.

Reports are good, but in the end, only the code can be trusted.

Updated dependencies

BrowserUpProxy from 2.2.2 to 2.2.3
LittleProxy from 2.0.11 to 2.0.12
Netty from 4.1.80.Final to 4.1.82.Final
slf4j from 2.0.0 to 2.0.2
JUnit from 5.9.0 to 5.9.1 – see release notes

Announced partial mobilization of dependencies!

News

The series from Dilpreet Johal continues - now Upload file with Selenide
Alchemy or Translating JIRA with Selenide by Tomasz Buga
Java 19 has been released.

Statistics

Latest Selenide download statistics only makes us happy. We passed the 400 thousands line!

Andrei Solntsev

selenide.org

Released Selenide 6.7.4

2022-09-05T00:00:00+00:00

Hey there!

We did yet another nano-release Selenide 6.7.4.

Added setting `remoteReadTimeout`

I recently complained about too many settings in Selenide.

Nevertheless, we added yet another setting Configuration.remoteReadTimeout (a.k.a. -Dselenide.remoteReadTimeout).

It may be useful if you run browser on a remote server, but the number if browser is limited on that server, and your tests need to wait in a queue for a free browser. In this case the default timeout for 1.5 minutes might not be enough, and you need to increase the timeout.

Personally, I call it HELL on the project, but who are we to stop people from voluntarily frying in a pan …

Now you can set any timeout from build scripts, command line etc.

Thanks to Rodion Goritskov for PR 1936.

Fixed mini-bug in “Dead threads watchdog”

Have you ever seen java.lang.IllegalStateException: Shutdown in progress in logs?

It means you hasn’t upgraded to Selenide 6.7.2 :)

Now I recommend to upgrade to 6.7.4 - and you get fixed both memory leaks and IllegalStateException.

See issue 1942 and PR 1943.

Upgraded dependencies

PR 1932 Bump Netty from 4.1.79 to 4.1.80

News

Andrei Solntsev

selenide.org

Released Selenide 6.7.3

2022-08-27T00:00:00+00:00

Good saturday!

You are reading release notes for Selenide 6.7.3.

Added condition `partialValue`

Similarly to $.shouldHave(partialText("Good Co")), now you have $.shouldHave(partialValue("Cola")).

It’s needed if you set Configuration.textCheck = FULL_TEXT, but need to check a value of some input or textarea partially.

See issue 1923 and PR 1924.

Added condition `tagName`

You probably don’t need it often. Because we often find element by the tag, and only then verify some its attributes.

Anyway, now you can verify the tag name of an element:

$(".btn-primary").shouldHave(tagName("button"));

Or filter a collection by tag name:

$$(byText("Submit!")).filterBy(tagName("button"));

See issue 1928 and PR 1929.

Now we check that element is `<select>`

… in methods $.getSelectedText() and getSelectedValue().

The initial intention of these methods was to find a selected <option> in a <select> and return its text or value.

But

it’s not obvious from the name (and that’s why we renamed methods to $.getSelectedOptionText() and getSelectedOptionValue())
you could call these methods on any other element but <select> - and get an unpredictable behavior.

Now call to $("div").getSelectedOptionText() will throw IllegalArgumentException.

See PR 1934.

Updated dependencies

PR 1932 Bump webdrivermanager from 5.2.3 to 5.3.0
PR 1931 Bump slf4jVersion from 1.7.36 to 2.0.0
PR 1921 Bump browserup-proxy-core from 2.2.1 to 2.2.2

News

Selenide puzzler Logical AND or OR?
Selenide got to Top Java Frameworks to Use in 2022

And finally, the main achievement:

Selenide got mentioned on official Selenium site in category “Ecosystem”!

Impossible!

It hasn’t even been 10 years!

Wait, it’s been…

Andrei Solntsev

selenide.org

Selenide puzzler

2022-08-22T00:00:00+00:00

Good night!

Do you love puzzlers? Did you miss puzzlers?

We recently published a new puzzler in Twitter:

Do these lines work equally? Or is there some difference?

1. $(".btn").shouldBe(visible, enabled);
2. $(".btn").shouldBe(visible).shouldBe(enabled);

Answer options

You gave us many answers:

both lines work equally (the most popular answer)
the first case is “logical or”, and the second is “logical and”
the second runs %timeout% seconds longer
the first runs with one timeout, the second run with two timeouts
the first fails if one of conditions is false, the second fails if the element is not visible, but is enabled.

Correct answer

In most cases both variants work equally.

Both variants is “logical AND”. In both cases Selenide will check that the element matches both conditions.

	enabled	disabled
visible	ok	nok
invisible	nok	nok

But there is a nuance.

The nuance

The difference will appear if the element meets the conditions not immediately, but after some time. Moreover, the first condition should be met in less than 4 seconds, and the second - in more than 4 seconds. (Say, it gets visible after 3.5 seconds, and enabled - after more 3.5 seconds).

The thing is that the method shouldHave has the timeout (by default 4 seconds), while conditions (visible, enabled, cssClass, text) don’t have any timeouts - they can just check “matches” or “doesn’t match”.

Example

For example, let’s open Traffic light. The light gets green after 3.5 seconds, and after next 3.5 seconds a text “Go!” appears on it.

The first variant checks if the light gets both color and text during 4 seconds:

  $("#light").shouldHave(cssClass("green"), text("GO!")); // timeout 4 seconds

This variant fails because the light doesn’t get both color and text in 4 seconds (it gets the text “Go” after 7 seconds).

The second variant will not fail:

$("#light")
  .shouldHave(cssClass("green")) // timeout 4 seconds
  .shouldHave(text("GO!")); // another timeout 4 seconds

The first shouldHave waits until the element gets green (and it gets during 4 seconds). Then the second shouldHave gets started which waits until the element gets text “Go!” (and it gets it during next 4 seconds).

Apparently, the closest answer was “the first runs with one timeout, the second run with two timeouts”.

Your puzzlers?

Do you have your own puzzlers? Share with us! Send us! Send’em all! Let’s guess them together!

Andrei Solntsev

selenide.org

Released Selenide 6.7.2

2022-08-14T00:00:00+00:00

Good Sunday!

We made a mini-release Selenide 6.7.2 fixing a few memory leaks.

But don’t worry, they are non-critical. It is unlikely that any of you even noticed them.

Fixed a memory leak with shutdown hooks in Selenide

If you open and close a browser multiple times in a test

for (int i = 0; i < 1000; i++) {
  open("about:blank");
  closeWebDriver();
}

then memory consumption starts growing:

It’s caused by shutdown hooks that Selenide adds for every opened browser. And never removes them until the end of JVM.

See issue 1917 and PR 1919.

After upgrading to version 6.7.2, memory consumption doesn’t grow anymore:

Fixed a memory leak in LittleProxy

We upgraded to LittleProxy 2.0.11 which also contains a memory leak fix.

See PR 1918 and PR 141

Upgraded to Selenium 4.4.0

which even contains one my personal fix! Which, by the way, helped us fix the next problem.

See PR 1913 and Selenium changelog

Fixed `full-size-screenshot` plugin

Our new plugin full-size-screenshot had one known problem (caused by a known bug in Selenium): if you run a browser remotely and open multiple tabs or windows, Selenide might take screenshot from a wrong window.

This bug was fixed in Selenium 4.4.0, and now in Selenide too.

See PR 1920 and PR 10811.

Released Selenide 6.7.0

2022-08-04T00:00:00+00:00

Good day!

We’ve got a big release Selenide 6.7.0

Now `$.shouldHave(text)` can verify the whole text

From the very beginning, command $.shouldHave(text) verified the text partially, not the whole text:

  <div id="freedom-to">Britney Spears</div>

  $("#freedom-to").shouldHave(text("Brit"));  // was OK

Initially, this seemed like a good idea, because a web page often contains all sorts of inconsiderable/invisible characters. (newlines, tab characters, non-portable spaces, multiple spaces, etc.).

But now it seems that it was still a bad idea, because beginners assume by default that the text is verified entirely, and snatch their portion of WTF moments when they discover that all their checks were checking a little wrong. :)

And Selenide learned to ignore differences in the inconsiderable characters (for example, multiple subsequent spaces/tabs/newlines are considered as a single space).

NB! Since this change is too drastic and will probably break a bunch of your tests, we left the previous behaviour as a default. And the new one can be enabled with this setting:

  Configuration.textCheck = FULL_TEXT;

And when you need to check a substring, you can use the new check partialText:

  $("#freedom-to").shouldHave(partialText("ey Spear"))

Perhaps we will enable this mode by default in the next major version of Selenide 7.0.0 - until then you can play around and give us feedback.

See issue 1780 and PR 1783.

Full-size screenshots

Finally!

Now Selenide can take full-size screenshots.

When a test fails, Selenide automatically takes a screenshot to help you understand why the test failed. By default, the webdriver captures only the visible part, not the entire browser window. But the most important things are often located outside the screen. The test failure is often caused by some disabled button at the bottom of the screen or a pop-up notification somewhere in the corner.

Now you can apply a plugin that takes a screenshot with the full content of a web page in one line:

testImplementation "com.codeborne:selenide-full-screenshot:6.7.0"

P.S. This plugin works only in browser supporting CDP (Chrome, Edge etc.) and Firefox. In other browsers, Selenide will take standard screenshots as usually.

See issue 1799 and PR 1858. Thanks to Aliaksandr Rasolka for PR 1800.

Caching of page object elements

As you know, Selenide supports “standard” Selenium page objects with annotations like @FindBy. But one specific annotation @CacheLookup was not supported by Selenide. It seemed an unneeded optimization because during test run, most of the time is usually spent on other things.

Now we support the caching, why not. Who knows, probably has so much optimized project that the search of web elements became a bottleneck. I would like to see such a project. :)

Thanks to Ilya Koshaleu for PR 1894.

P.S. The question arises, should we also add caching for regular $ and $$ as well. What should be the api: a parameter, a setting? New method?

Suggest your ideas!

Cancelled TestNG annotation `@Report`

Now the cancel culture has reached the annotations!

If you use TestNG and Selenide text report, this announce is for you. Until now, you had to add 2 annotations to your tests:

  @Listeners({TextReport.class})
  @Report
  class MyTest {...}

Why we did this is a long story about the clumsy principles of how listeners work in TestNG (in short: adding a listener annotation to one class suddenly affects all other classes). But now we realized that the system can be simplified: the @Report annotation is no longer needed.

Now Selenide report will be generated for all tests annotated with @Listeners({TextReport.class} and their child classes.

See issue 1891 and PR 1909.

Decode downloaded file name

It turned out that when downloading a file, the file name in the server response is sometimes encoded in Base64. And Selenide was reading this encoded file name as is. Now Selenide decrypts the file name.

See issue 1886 and PR 1889.

Fixed `$.setValue()` in IE

It turns out we recently broke the $.setValue() method in Internet Explorer. We assumed people don’t use IE anymore: IE has officially given up. But there were complaints, and we restored IE support.

See PR 1907.

Made `HttpClientTimeouts` public

See PR 1902.

Returned parameter type to `String` for method `$.setValue()`

Personally, it burns me from the fact that such a problem arose at all.

See details in issue 1885 and PR 1888.

Added a warning about invalid file extension parameter

See PR 1887.

Updated dependencies

UPD Selenide 6.7.1

restored parameter Driver in method SelenidePageFactory.findSelector() - it’s used by selenide-appium plugin.

News

Opinionated reporting framework for Selenide by Ulrich Mayring
Extending open-source libraries: Selenide & Selenium - Selenium Conf, 30.07.2022
Flaky Tests - devclub.ee, Tallinn, 05.07.2022

Andrei Solntsev

selenide.org

Released Selenide 6.6.6

2022-07-01T00:00:00+00:00

Good evening!

We made another release Selenide 6.6.6

Removed deprecated capabilities

Some webdriver options (which Selenide has been setting for years) were later marked as deprecated.
Starting from some release, Selenium started logging warnings about them.

Now Selenide doesn’t set them anymore: acceptSslCerts, handlesAlerts, javascriptEnabled, takesScreenshot.

We will not forget you, friends! You have served us faithfully for over 10 years.

See issue 1862, issue 1866 and PR 1870.

Fixed ClearWithShortcut

… when working with driver wrapped into listeners. It’s rare, don’t worry.

Thanks to Petro Ovcharenko for PR 1856.

Added shorter syntax for `$.click`

If you wished to click with an offset or custom timeout, you had to write quite a long line:

$.click(withDefaultMethod().offset(123, 222));
$.click(withDefaultMethod().timeout(...));

Now you can write a shorter line:

$.click(withOffset(123, 222));
$.click(withTimeout(...));

See PR 1875.

Added support for mobile apps

… when checking if webdriver is still alive.

This is a minor fix for selenide-appium.

When you reuse the same webdriver for multiple tests, Selenide needs to regularly check if the webdriver is still alive. To check it, Selenide calls WebDriver.getTitle().

Recently we realised that method getTitle() is not supported in Appium. Now we handle this situation properly, and the browser health check works in Appium too.

See issue 1878 and PR 1879.

Fixed logic of `reopenBrowserOnFail` setting

Another improvement for testing mobile apps.

See issue 1880 and PR 1881.

Upgraded dependencies

WebDriverManager from 5.2.0 to 5.2.1.
byteBuddyVersion from 1.12.11 to 1.12.12.

Released selenide-appium 2.1.0

This version contains improved support for running tests for iOS applications.

See selenide-appium.

With this release, we decided to demonstrate to the world community that we do not interfere with the creation of automated tests for mobile applications.

Now it’s up to the automators.

Andrei Solntsev

selenide.org

Released Selenide 6.6.4

2022-06-20T00:00:00+00:00

Gootas morningas!

We made another mini-released Selenide 6.6.4.

Added condition `exactTextsCaseSensitive` for collections

Selenide has several built-in checks for collections texts:

$$("li").shouldHave(texts("foo", "bar", "baz"));
$$("li").shouldHave(textsInAnyOrder("foo", "bar", "baz"));
$$("li").shouldHave(exactTexts("foo", "bar", "baz"));
// etc.

Now there is one more check available:

$$("li").shouldHave(exactTextsCaseSensitive("foo", "bar", "baz"));

Thanks to Ben Heap for PR 1861.

Made method `$.getSelectedOption()` lazy

By design, (almost) all Selenide methods should be lazy.

For example, call to $("#nope") does NOT fail even if the element doesn’t exist. It allows writing negative checks, e.g.

$("#nope").shouldNot(exist);

We realized we method $("select").getSelectedOption() was not lazy. It failed immediately if the select was not loaded yet etc.
So you could not write such a negative check:

  var option = $("select#gender").getSelectedOption();  // failed on this line
  option.shouldNot(exist);

Now we have corrected this issue. The laziness won! See issue 1581 and PR 1864.

Updated dependencies

Netty from 4.1.77.Final to 4.1.78.Final.
BrowserUp proxy from 2.1.5 to 2.2.0.

UPD Released Selenide 6.6.5

One more mini-release Selenide 6.6.5.

Upgraded Selenium from 4.2.2 to 4.3.0.

This is our frank response to your frank request.

Andrei Solntsev

selenide.org

Released Selenide 6.6.3

2022-06-12T00:00:00+00:00

Good evening fellows!

We made a mini-release Selenide 6.6.3.

Improved timeout for `$.click()`

In version 6.6.0, we added an optional parameter timeout for method $.click().
But it appeared that it only partially solved the problem.

Now we improved it: method

$("#slow-link").click(usingDefaultMethod().timeout(ofSeconds(8)));

waits 8 seconds for both the element itself and the following page loading.

See issue 1572 and PR 1853.

Selenide 6.6.2

A day before, we released Selenide 6.6.2 with upgrade to Selenium 4.2.2

See PR 1851.

Selenide 6.6.1

Before this, we released Selenide 6.6.1 with a tiny fix for an old issue 1850. We restore byte-buddy dependency which was needed for adding listeners to webdriver.

Andrei Solntsev

selenide.org

Released Selenide 6.6.0

2022-06-08T00:00:00+00:00

Good morning, friends!

We released Selenide 6.6.0.

Added new Selenide plugin `selenide-clear-with-shortcut`

In Selenide 6.5.0, we changed the implementation of $.clear() method from a standard WebDriver to a shortcut (“Select all” -> “Delete”).
Later we realized this shortcut didn’t work stably in all browsers, we had to rework it. It got more stable, but slower. And since it’s not really needed for all, we decided to return the old good WebElement.clear().

And if you need the smart $.clean() method with shortcuts - you can add the brand new Selenide plugin:

  testImplementation('com.codeborne:selenide:6.6.0')
  testImplementation('com.codeborne:selenide-clear-with-shortcut:6.6.0')

Dependency com.codeborne:selenide-clear-with-shortcut will override method $.clear() - and $.setValue() correspondingly.

See issue 1497, PR 1847 and PR 1838.

Fix method `$.clear()` in Safari

We found that new $.clear() didn’t work in Safari browser (who uses it nowadays?).
I hope we fixed it. :)

See issue 1819 and PR 1820.

New checks for element own text

Added two new checks for element’s own text:

$("#child_div1").shouldHave(ownTextCaseSensitive("Son"));
$("#child_div1").shouldHave(exactOwnTextCaseSensitive("Son"))

Thanks to Kachurin Alexandr for PR 1811 and PR 1812.

Added method `$.click()` with timeout

By default, method $.click() has the standard Selenide timeout (which is initially 4 seconds).
Sometimes it’s not enough - for example:

if clicking a link opens a new page which loads longer than 4 seconds.
if the element which we are going to click is not visible yet, and appears after more than 4 seconds.

In this release, we added timeout parameter to method $.click:

  $("#slow-link").click(usingDefaultMethod().timeout(ofSeconds(8)));
  $("#slow-link").click(usingJavaScript().timeout(ofSeconds(8)));

Though, it solves only the first problem. In next release we will also solve the second. :)

See issue 1572 and PR 1845.

Added timeout to methods `confirm()`, `dismiss()` and `prompt()`

These methods existed from the very beginning of Selenide era. They allow working with JavaScript modal dialogs (alert, confirm, prompt). For example:

confirm();
confirm("Are you sure you want to delete all files?");

But they could not have any other timeout except the default one. Now you can pass a timeout parameter:

confirm(withTimeout(ofSeconds(2)));
confirm(withExpectedText("Are you sure?").timeout(ofSeconds(2)));

See issue 1721 and PR 1846.

Fixed method `Driver.executeJavaScript()`

…to support a wrapped webdriver (i.e. when you have added some listeners to the webdriver).

See PR 1848.

Fixed phrasing of some checks

… to sound correctly in English. Namely:

In a test	Was in report	Now in report
`$.should(appear)`	“Element should visible”	“Element should be visible”
`$.should(disappear)`	“Element should hidden”	“Element should be hidden”

See PR 1840.

Restored Safari options

We realized that after upgrading to Selenium 4, we lost most of Safari options.
It was easy to fix, yet… why nobody did complain on it?

Looks like nobody is using Safari… :)

See issue 1836 and PR 1841.

Fixed soft asserts in TestNG

After upgrading to TestNG 7.5, Selenide soft asserts didn’t work anymore. If some check failed, your tests still remained green.

We had to downgrade to TestNG 7.4.0 and hope for the fix on the dark side. :)

See issue 1834 and PR 1843.

Upgraded dependencies

Selenium 4.1.4 -> 4.2.1.
WebDriverManager 5.1.1 -> 5.2.0

Statistics

We haven’t published Selenide download statistics for a long time:

We’re almost back to our all-time high of 324k downloads in May.

Stay tuned!

Andrei Solntsev

selenide.org

Released Selenide 6.5.0

2022-05-17T00:00:00+00:00

Good night!

We released Selenide 6.5.0.

Now you can mask passwords in reports

Sometimes you need to type passwords and other sensitive data into input fields. Sometimes people don’t want this data to be visible in test reports (e.g. Allure or TextReport). And ask to hide this sensitive data somehow.

I personally never understood why it’s a problem.
Why the password from test environment should be a problem?
You don’t use the same password in production, right?
You don’t run tests in production, right?

Anyway, we made it possible to mask sensitive data in test reports:

  $("#password").setValue(withText("admin").sensitive());
                                         // replaces by "********"

  $("#username").setValue(withText("john").withDisplayedText("J* username"));
                                         // replaces by "J* username"

See issue 1768 and PR 1770.

Now you can easily pick a date in `<input type=date>`

It’s not a trivial task to pick a date in Selenium.

When your application has element like <input type=date>, and your test tries to click it, different browsers open different calendars and use different date formats. In theory, they should use format based on user settings, but in reality each browser plays its own game.

This causes flaky tests that might work on your machine, but occasionally fail on others.

As a result of my investigation, I found that the only stable way to pick a date is setting a value in format yyyy-mm-dd using JavaScript snippet. It seems to work in all OSs and browsers.

Now you can easily do it with new method withDate:

  LocalDate birthday = LocalDate.parse("1979-12-31");
  $("#birthday").setValue(withDate(birthday));

See issue 1753 and PR 1770.

Now method `$.setValue("")` supports React, Vue.js etc.

Standard Selenium method WebElement.clean() (e.g. it’s used in Selenide method $.setValue()) doesn’t always work when the application uses some tricky constructions (generated by React/Vue/…) instead of standard <input>.

Hopefully, we have fixed it. Waiting for your feedback.

Now the following 2 methods abandoned using WebElement.clear(). They use key combinations instead:

1. Method `$.clear()`:

input.sendKeys(HOME, chord(SHIFT, END), BACK_SPACE);

2. Method `$.setValue("")`:

input.sendKeys(HOME, chord(SHIFT, END), BACK_SPACE, TAB);

This new way seems to work in all OSs and browsers.

See issue 1497 and PR 1787.

Thanks to Alexei Vinogradov for the research in PR 1499.

Removed triggering duplicate `blur` and `change` events

As a result of previous change, method $.setValue("blah") triggers blur and change events only once.

Before this release, method $.setValue("blah") worked in two steps and therefore triggered events twice:

Step 1. $.clear() // triggered blur and change
Step 2. $.sendKeys("blah") // triggered blur and change once more

The events triggered on the first step could cause unexpected effects, including disappearing of the field itself.
See issue 960.

Trigger `blur` on a previous element

During working on the previous change, we improved method $.setValue("blah") so that it triggers blur event on a previous active element. At least it helped to fix some of our flaky tests. Hopefully, it can improve your tests as well.

See issue 1784 and commit 593e6fc9005.

Now method `$.setValue()` and `$.append()` check that element is not disabled or readonly

See issue 1523 and PR 1787.

Added conditions “interactable” and “editable”

These conditions existed inside of Selenide, but were not available to end-users.
Now you can also use them:

$("input[type=file]").shouldBe(interactable);  
             // interactable = visible OR "opacity: 0"

$("input").shouldBe(editable);
             // editable = interactable AND enabled AND !readonly

See issue 1523 and PR 1787.

Method `$.download(FOLDER)` waits for full download completion

Sometimes test might be flaky when it tries to download a file which is being downloaded very slowly. Selenide might detect and copy the file in C:\Downloads folder which is not fully downloaded yet.

Now Selenide waits until C:\Downloads doesn’t contain any files “.crdownload” (for Chrome) or “.part” (for Firefox). This is a temporary file created by the browser for a short period of time while the file is beging downloaded.

See issue 1779, PR 1804 and PR 1769.

Added method `stream()` for collections

Actually, method $$.stream() already existed, but was deprecated in version 6.2.0. Now you can pick one of two non-deprecated replacements:

$$.asFixedIterable().stream()
$$.asDynamicIterable().stream()

See issue 1773 and PR 1774.

Remove Selenium built-in OpenTelemetry

If I am not mistaken, this “telemetry” was added Selenium 4. I have no idea why it’s needed, but it could interfere with someone who already had their own telemetry.
It was simpler for us to remove it than support both. :)

Thanks to Petro Ovcharenko and Aliaksandr Rasolka for PR 1763.

Upgraded dependencies

By the way LittleProxy projects moved to a dedicated github organisation, and I became the main maintainer of the project. I was never a big fan of proxies, but LittleProxy is used inside of Selenide, and somebody needs to maintain it…

UPD Selenide 6.5.1

A small update Selenide 6.5.1:

#1808 Fixed $.clear() so that it doesn’t press tab anymore – see PR #1809
#1806 Bump browserup-proxy-core 2.1.4 to 2.1.5

UPD Selenide 6.5.2

#1497 Fixed method $.clear() on a fresh Firefox: now it presses “Ctrl+A -> Delete” instead of “Home -> Shift+A -> Delete”. See PR #1838.

Stay tuned!

Andrei Solntsev

selenide.org

Released Selenide 6.4.0

2022-04-07T00:00:00+00:00

Good evening, friends!

We released Selenide 6.4.0.

Now we show both alias and locator on test failure

In Selenide, you can use method as to give web elements readable names.
It may be useful when the element has no good ID/class, and you have no choice but write long ugly unreadable xpath. It’s hard to read such selectors in reports.

Sample usage of as:

$x("/long/ugly/xpath/div[2]/span[3]/li[4]").as("Login button").click();

We always had a dilemma: should Selenide

show only alias (pros: easily readable, cons: locator is not visible - but it might be helpful)
show both alias and locator (pros: locator is visible, cons: hard to read).

Finally, we realized what is the right way.

Starting from version 6.4.0, Selenide will:

Show only alias in reports (@TextReport, Allure report etc.)
Show both alias and locator in error message in case of test failure

For example, the code mentioned above will look like this in report:

+----------------------+--------------------+------------+------------+
| Element              | Subject            | Status     | ms.        |
+----------------------+--------------------+------------+------------+
| Login button         | click()            | FAIL       | 206        |
+----------------------+--------------------+------------+------------+

And in error message:

Element "Login button" not found {By.xpath: /long/ugly/xpath[1][2][3]}
Expected: exist
Screenshot: ...

See issue 1765 and PR 1766.

Added spaces in Selenide report

The report mentioned above looked like this until now:

+---------------------+-------------------+------------+------------+
|Element              |Subject            | Status     | ms.        |
+---------------------+-------------------+------------+------------+
|open                 |https://google.com/some-long-url.html?q=selenide|PASS       |1285       |
|Login button         |click()            | FAIL       | 206        |
+---------------------+-------------------+------------+------------+

The problem is that the long URL is wrapped with | characters on the left and right. It makes it impossible to easily select it with double click. Now a space will be added to the left and right of the URL and other values in the report.

And the report looks now nicer, right?

See issue 1764 and PR 1767.

Upgraded to Selenium 4.1.3

See Selenium changelog and PR 1759.

Andrei Solntsev

selenide.org

Released Selenide 6.3.0

2022-02-07T00:00:00+00:00

Hello, people!

We released Selenide 6.3.0.

Let’s review what’s changed?

Added methods `switchTo().frame(timeout)` with custom timeout

Selenide has methods switchTo().frame(name) for switching between frames. As usually, with built-in waiting and other bonuses.
But what if the frame is being loaded longer than the default timeout (4 seconds)?

Now you can pass an additional parameter Duration - the timeout for switching into the frame:

  switchTo().frame("ifrm");                          // waits up to default timeout (4 seconds)
  switchTo().frame("ifrm", Duration.ofSeconds(6));   // waits up to 6 seconds

Thanks to @donesvad for PR 1722.

Added selectors `byTagAndText` and `withTagAndText`

Selenide has method for finding elements by text:

  import static com.codeborne.selenide.Selectors.*;

  $(byText("Hello world")).shouldHave(text("Hello World"));
  $(withText("Hello")).shouldHave(text("Hello World"));

But sometimes it’s not enough: if there are multiple elements with given text, and you need to pick one of them by tag.

Now Selenide has methods for find by tag and text:

  import static com.codeborne.selenide.Selectors.*;

  $(byTagAndText("h1", "Hello world")).shouldHave(text("Hello World"));
  $(withTagAndText("h1", "Hello")).shouldHave(text("Hello World"));

Thanks to Maurizio Lattuada for issue 1650 and PR 1651.

Fixed bug in `byTextCaseInsensitive`

Now this selector ignores leading/trailing spaces and newlines in the text (like the canonical byText).

See issue 1723 and PR 1724.

Added records “webdriver create” and “webdriver close” to report

If you use Selenide’s TextReport or plugin AllureSelenide, you are used to see the report in the end of every test.
The report shows all the performed steps: open a page - find an element - click etc.

Now the report also shows moments when the webdriver was created or closed. This information may be useful when debugging some problems with tests.

Thanks to Petro Ovcharenko for PR 1715.

Fixed overriding of Selenium timeout

In Selenide 5.22.0 we introduced a hack for overriding Selenium webdriver timeout from (unreasonably long) 3 hours to 2 minutes.

But this hack was broken after upgrade to Selenium 4 (as it always happens to all hacks). Now we reanimated it.

Let me remind that Selenide now has the following timeouts in communication between tests and webdriver:

connect timeout - 10 seconds
read timeout - 1.5 minutes

See commit cf02da5.

Removed duplicate wrapping of “Element not found”

See issue 1705 and PR 1706.

Added support for authentication type `BEARER`

Selenide has several types of authentication:

open("/basic-auth/hello", BASIC, "scott", "tiger");

but only BASIC did really work. Nobody ever tested the other types. :)

And we found that BEARER type didn’t work. Now we fixed it.

This is how you can use it:

    open("/bearer-token-auth/hello", BEARER, new BearerTokenCredentials("token-123"));

See PR 1714.

Now Selenide treats empty settings like `selenide.remote` as undefined

This change should make devops’ life easier. When configuring CI pipelines and jobs, you often use variables to set Selenide settings:

-Dselenide.remote=${env.GRID_URL}

If GRID_URL variable is not set in some environment, Selenide failed because it tried to parse empty url to set selenide.remote.

Now Selenide will treat empty setting like selenide.remote just undefined and continue work as usually (like selenide.remote was never set).

See Alexei Vinogradov for issue 1656 and Boris Osipov for PR 1663.

Upgraded to Selenium 4.1.2

A heard some users experienced problems with Guava version after upgrading to Selenium 4.1.2. Selenide defined Guava version explicitly, so generally you should not experience such a problem. If you still get something like NoSuchMethodError, please verify the guava version: pribably it’s overridden by some Gradle or Maven plugin. Please refer the old good post about resolving dependencies if needed.

See Selenium changelog and PR 1719.

UPD Selenide 6.3.1

Minor update Selenide 6.3.1:

#1731 we restored possibility to use soft asserts in TestNG in methods @Before* and @After* (we occasionally forbidden them it Selenide 6.2.0) - see PR #1732
#1729 Upgraded from Netty 4.1.73.Final to 4.1.74.Final

UPD Selenide 6.3.2

Another update Selenide 6.3.2:

#1733 Added a workaround for Selenium bug 10345, which caused failure of method FirefoxDriver.close() after upgrading to Firefox 97.
#1736 Upgraded from BrowserUpProxy 2.1.3 to 2.1.4
#1611 Upgraded Java version from 8 to 17.

Let me explain the Java update. Now Selenide project is built with Java 17, but the generated binaries selenide-*.jar are targeted to Java 8. This allows

Selenide developers use all the latest Java features, and
Selenide users still run their tests on Java 8 (though we recommend upgrading Java, of course).

It became possible thanks to the tool Jabel and personally Sergei Egorov who came up with this elegant hack (and also involved in TestContainers and AtomicJar).

UPD Selenide 6.3.3

One more minor update Selenide 6.3.3:

#1737 allow overriding Firefox preferences for downloading files
#1740 upgraded to WebDriverManager 5.1.0

UPD Selenide 6.3.4

Another update Selenide 6.3.4:

#1746 show the expected attribute when $.shouldHave(attribute(...)) fails.
#1748 fixed module name in generated Selenide binaries

UPD Selenide 6.3.5

Another update Selenide 6.3.5:

#1755 fix file download via proxy in case of encoded response - see PR #1756

News

We created a group in LinkedIn: Selenide User Group!
Post by Miklós Szeles Selenium or Selenide?
Selenide got to compilation 5 Testing Automation Tools in Qameta Software blog (Allure Report maintainers)
Selenide got to compilation Top Java Libraries for Automation Testing in 2022
Post about Selenide in Knoldus blog
Post The software that doesn’t need documentation by Gaveen Nayanajith
Post the beginning of a beautiful friendship by Miklós Szeles

I think this is the beginning of a beautiful friendship!

Andrei Solntsev

selenide.org

Released Selenide 6.2.0

2022-01-10T00:00:00+00:00

Happy New Year, people!

We released Selenide 6.2.0.

Let’s look into this year’s first release.

Pour some tea and let’s go!

Added link “<Click to see difference>” for most of Selenide assertion errors

As you remember, in Selenide 5.25.0 we added Test4J support. As a result, Selenide assertion errors got a link “<Click to see difference>” in IDE which allows to easily compare expected and actual values in case of test failure.

At that moment we didn’t have enough time to refactor all the assertion errors, and some of them didn’t get the link.
Now we added the link to all the errors.

See issue 1589 and PR 1676.

Replaced `$$.iterator()` by `$$.asDynamicIterable()` and `$$.asFixedIterable()`

Wow, what an old sore we have fixed!

Selenide has method $$ for a collection of web elements. It returns instance of class ElementsCollection.
Initially, it should have only one method $$.shouldHave(<condition>). When you want to verify the collection - pass it the needed condition. If you didn’t find a needed condition - create your own, it’s easy.

The mistake

But I did a mistake at that moment. I inherited class ElementsCollection from AbstractList<SelenideElement>. I later regretted this decision many times.

What happened, you may ask? People started abusing the collections.

For example, they wanted to iterate the collection elements (and it occasionally was possible because of extending AbstractList).
they expected that the collection elements will be reloaded during the iteration (because Selenide had been updating all other web elements during checks & re-tries).
In addition to the questionable test design, this also caused performance problems, because at every iteration step Selenide must reload the entire collection. And it can be slow, especially if there are many elements in the collection, or the collection is being filtered: $$("div").filter(visible).filterBy(text("Hello")).

The dilemma

The dilemma turned out:

some people wanted Selenide to reload collection elements during the iteration (because it helps to avoid StaleElementException etc when the elements appear and disappear during the iteration);
other people didn’t want Selenide to reload the elements because it makes tests faster on big collections.

Whichever option we choose, we won’t please everyone.

The solution

Finally, we figured out how to solve this dilemma. We deprecated all these methods like $$.iterator() which were occasionally inherited from AbstractList. As a replacement, we suggest two new methods. You can choose one of them depending on your needs:

$$.asDynamicIterable() - reload the elements during the iteration. Might be slow on big collections.
$$.asFixedIterable() - doesn’t reload the elements. May be faster, but will not get updates if elements appear/disappear during the iteration.

The recommendation

Which one I recommend to you, you may ask?

NONE!

In the end, let me remind that well-designed test should not have loops, ifs etc. You must know how many elements are expected, and which properties they are expected to have. Just verify those properties.

Instead of iteration, it’s always better to create your custom CollectionCondition. It’s easy.

See issue 797 and PR 1688.

Fixed SoftAssert to avoid failing a test

in a rather rare situation:

when soft assert listener/rule/extension is added to a test, but
soft asserts are disabled, and
there was an assertion error raised and caught during the test execution (try/catch).

It sounds like a design smell. Probably such test should be fixed. :(

But still, we fixed the Selenide soft assert listener. Now it doesn’t fail the test if soft assertions are disabled.

Uh, well, you sometimes throw up unexpected problems, dear users … :)

See issue 1646 and PR 1680.

We fixed soft asserts to include all the errors

There was one more rare problem with soft asserts. Image the situation:

You have soft asserts enabled;
During the test execution, some Selenide assertion errors were raised (and caught by the listener);
But there was also some other assertion error (like NPE or assertEquals(2, 3)).

In this case, Selenide soft assert listener failed the test (which is correct), but showed only Selenide assertion errors (#2) and lost the “other” error (#3).

Now the listener got smarter: it merges all the assertion errors.

See issue 1661 and PR 1679.

We added locator to some of Selenide assertion errors

Another small improvement.

We added a locator to some of Selenide assertion errors.
For example, if previously you could see an error like this:

“Invalid element state: Cannot change invisible element”

then now you will see the improved error message:

“Invalid element state [.btn.btn-primary]: Cannot change invisible element”

Upgraded BrowserUpProxy from 2.1.2 to 2.1.3

Note that version 2.1.3 is a fork of the original BrowserUpProxy. The authors announced the end of support, and the volunteers took over and released version 2.1.3 from the fork.

We will monitor the situation. Ideally, it would be great to switch from BrowserUpProxy to mitmproxy. Are there volunteers?

See PR 1678.

Upgraded TestNG from 7.4.0 to 7.5

Changelist is quite impressive.

See PR 1682.

Happy New Year, my friends!
I wish you stable tests and beautiful reports!

Andrei Solntsev

selenide.org

Released Selenide 6.1.1

2021-11-24T00:00:00+00:00

TERE HOMMIKUST!

We released Selenide 6.1.1.

In this tiny release we fixed a bunch of problems with browser settings.
These problems arose after upgrading to Selenium 4 where ChromeOptions and other Capabilities were refactored.

Now we plunged into the topic and fixed all the problems at once.

Early conflict detection

If you try to open a Chrome with Firefox settings:

Configuration.browser = "chrome";
Configuration.browserCapabilities.setCapability(FIREFOX_OPTIONS, new FirefoxOptions());

then Selenide 5.x did show a clear error message, but Selenide 6.0.x didn’t.
Now we have restored the swearing, and you will see the old good

IllegalArgumentException: Conflicting browser name: ‘chrome’ vs. ‘firefox’

See issue 1591 and PR 1642.

Merging of chrome arguments

Say, if you want to run Chrome in full screen mode or setup its language:

ChromeOptions options = new ChromeOptions();
options.addArguments("--start-fullscreen", "--start-incognito");
options.setExperimentalOption("prefs", ImmutableMap.of("intl.accept_languages", "de_DE"));
Configuration.browserCapabilities = chromeOptions;
open("https://codeborne.com";)

then these settings were lost in Selenide 6.0.x
Now we have restored them.

See issue 1626, issue 1630 and issue 1631.

The fix was in PR 1642.

IMPORTANT

If you used Configuration.browserCapabilities, then with a high probability you wrapped it into DesiredCapabilities:

ChromeOptions options = new ChromeOptions();
options.addArguments(...);

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, options);
Configuration.browserCapabilities = caps;

Now you have to simplify your code, to avoid loosing of your settings:

ChromeOptions options = new ChromeOptions();
options.addArguments(...);
Configuration.browserCapabilities = options;

We changed the parameter type of `WebDriverProvider`

… from DesiredCapabilities to just Capabilities.

For you, almost nothing changes. If you use WebDriverProvider in your tests, simply change DesiredCapabilities to Capabilities and everything will work as previously.

See PR 1642.

More capabilities for the Capabilities God!

UPD Selenide 6.1.2

We released Selenide 6.1.2 with upgrade to Selenium 4.1.1. It has several remarkable bugfixes.

Andrei Solntsev

selenide.org

Released Selenide 6.1.0

2021-11-23T00:00:00+00:00

TERE!

We released Selenide 6.1.0.

Added support for `selenide.properties`

Now Selenide can read its settings from file selenide.properties if it’s found in classpath.

NB! I personally still don’t find it really useful. It’s easier to just set settings

right in code: Configuration.timeout = 8000;
or via system properties: -Dselenide.timeout=8000.

Please, don’t rush generating these files. Use selenide.properties only if you have a good reason, and not simply because it is now fashionable or “beautiful”.

Thanks to Petro Ovcharenko for PR 1601.

Added possibility for fine tuning the proxy

As you know, Selenide can run its embedded proxy server. It makes possible downloading of files, listening/intercepting requests etc. But capabilities of configuring the proxy were quite limited by now: only Configuration.proxyHost and Configuration.proxyPort.

Now you can get the instance of BrowserModProxy and set it up as you wish before opening a browser.

NB! Please don’t overuse it. It’s very easy to shoot yourself in the foot via re-configuring the proxy.

And don’t forget: if your settings really helped you, then maybe they will help others as well. Tell us what you set up there - maybe we should make these proxy settings default in Selenide?

See issue 1561. Thanks to Boris Osipov for PR 1620.

Added a workaround against random `NoClassDefFoundError` in `WebDriverException`.

There is a bug in Selenium which is not entirely fixed yet. But you will not see it anymore because we added a workaround in Selenide code. :)

See the workaround.

Changed parameter type for method `SelenideConfig.browserCapabilities()`

… from DesiredCapabilities to MutableCapabilities.

It allows to simplify your code. You don’t need to wrap ChromeOptions into DesiredCapabilities anymore. More about simplification of capabilities will be in the next release Selenide 6.1.1.

See PR 1637.

Upgraded to Selenium Webdriver 4.1.0

Thanks to Boris Osipov for PR 1638.

Removed method `$.shadowRoot()`

This method got broken after upgrading to Chrome 96, and probably will be broken in other browsers soon.
Taking into account that

It’s hard to fix this method, and
This method is not really useful since there are better ways to find elements in Shadow DOM. we decided to just delete this method. Easy! :)

See issue 1640 and PR 1641.

News

A QA/TestOps Hackaton by PropellerAds and Qameta Software. Register!
How to use Selenide with Lambdatest service
A post Selenide - Create a Custom WebDriver by Boris Bay
Wow! LinkedIn runs course on Selenide and even gives nice diplomas! :)

Selenide downloads statistics

In October we made a big leap and exceeded 280 thousand downloads per month.

More downloads for the Downloads God!

Andrei Solntsev

selenide.org

Released Selenide 6.0.1

2021-10-25T00:00:00+00:00

Happy Birthday, Selenide!

Wow! It’s hard to believe, but today Selenide got … 10 years old!

This day 10 years ago was created the first commit to Selenide github repository.

Many thanks to everyone who participated in the project, committed, reported bugs, suggested ideas, answered questions in the forums, criticized and talked about selenide at conferences and meetups. And who just decided to use Selenide in their projects. You are all part of this movement.

In honor of the anniversary, we released major version Selenide 6.0.1.

Upgraded to Selenium Webdriver 4.0.0

Nothing really should change for you until you are using Selenium Grid. Everything more or less works as before. Well, some classes were renamed or deprecated - it seems not scary.

Selenium 4 also brings new features (like CDP and Relative locators), but haven’t introduced any special support for them yet. Can work on it in next versions if needed.

See issue 1162, PR 1605, PR 1614 and PR 1617.

Splitted Selenide to several artifacts

Before now, the whole Selenide code was published as a single artifact: selenide-5.25.0.jar.
And you had to add other dependencies like JUnit or TestNG, and probably BrowserMobProxy.

Now we made it easier for you (especially with proxy).

For JUnit5 users the dependency will not change:
testImplementation("com.codeborne:selenide:6.0.1)
JUnit4 users should use
testImplementation("com.codeborne:selenide-junit4:6.0.1)
TestNG users should use
testImplementation("com.codeborne:selenide-testng:6.0.1)
If you want to use proxy, it’s enough to add dependency
testImplementation("com.codeborne:selenide-proxy:6.0.1) - and forget about all these BrowserUpProxy, Netty etc.
And if you happen to be a radical hater of static methods, now you can also be happy by declaring
testImplementation("com.codeborne:selenide-core:6.0.1) - and then you will only have SelenideDriver without Selenide.* static methods.

See PR 1612.

Removed lots of deprecated code

Here you can find what exactly was removed and how can you replaced it.
In particular,

ElementsCollection.shouldHaveSize() -> ElementsCollection.shouldHave(size())
$.waitUntil(_, timeout) -> $.should(_, Duration.ofMillis(timeout))
$.waitWhile(_, timeout) -> $.shouldNot(_, Duration.ofMillis(timeout))
Condition.disappears -> Condition.hidden
Condition.matchesText -> Condition.matchText
Selenide.close -> Selenide.closeWebDriver() or Selenide.closeWindow()

Thanks to Boris Osipov for PR 1607 and PR 1609.

Remove support for browser “legacy_firefox”

It was an old webdriver that worked with Firefox 52 and earlier. I guess it’s not used anymore.

See PR 1610.

Removed some old settings

`Configuration.startMaximized`

We think this is bad practice, because the size of the browser window depends on the current environment, which can lead to flaky tests. We recommend to use Configuration.browserSize instead (default value is 1366x768).

`Configuration.versatileSetValue`

Most probably you didn’t use it because it was false by default.
Now for selecting a value from <select> or <input type=radio> you can use plain old methods $.selectOptionByValue() and $.selectRadio().

Thanks to Boris Osipov for PR 1619.

Fixed method `Selenide.sleep(N)`

It turns out that the standard Java method Thread.sleep (N) does not necessarily sleep exactly N ms, it can wake up earlier. And this can cause flaky tests if your expected a certain pause.

Now method Selenide.sleep(N) is guaranteed to wait at least given number of milliseconds.

See implementation.

Added methods for adding/removing `WebDriverListener`

Selenide has method for adding WebDriverEventListener, but this class was replaced by WebDriverListener in Selenium 4.
So we have to support both.

See issue 1615 and PR 1616.

Changed signature of method `Condition.apply`

It doesn’t concern you until you created your custom Conditions.

Before now, class Condition had method apply which returned boolean:

public boolean apply(Driver driver, WebElement element) 

Now you need to rename it to check and return CheckResult instead of boolean:

public CheckResult check(Driver driver, WebElement element) 

This CheckResult contains not only flag “condition met / not met”, but also a actual value at that moment.
It allows Selenide to generate a better error message in case of test failure.

P.S. Though, old method apply is not removed, but just marked as deprecated. So you can postpone this refactoring for some time.

See issue 217, PR 1586 and PR 1618.

selenide-selenoid 2.0.1

We released selenide-selenoid:2.0.1 with upgrade to Selenide 6.0.1

selenide-appium

It seems that Appium doesn’t support Selenium 4 yet, so we cannot upgrade selenide-appium yet. Stay tuned.

UPD Selenide 6.0.2

We found a problem with projects using TestNG, released a hotfix 6.0.2.

See issue 1623

UPD Selenide 6.0.3

It appears that Maven can fetch an older version of selenium-api-3*.jar if it’s found in a dependency tree (usually in BrowserUpProxy or Allure transitive dependencies).

I personally find this Maven behaviour misleading and just wrong. Maven could pick up a newer version.
But since people often experience this problem, we decided to add a workaround on Selenide side.

See workaround 1625

What to read about Selenium 4

What’s New In Selenium 4? by Applitools
Selenium 4: Understanding Key Features by BrowserStack
A comprehensive guide to Selenium 4 by SauceLabs
What Is New In Selenium 4 And What Is Deprecated In It? by LambdaTest
Updated Selenium website

Other news

Aerokube released alternative WebDriver client. In theory, Selenide could now use it under the hood instead of Selenium Webdriver. Sounds tempting?
I haven’t figured it out yet, but people seem to be praising it: some Docker images for Selenium

Selenide download statistics

We crossed 255K downloads per months!

What is waiting us in next 10 years?

Andrei Solntsev

selenide.org

Released Selenide 5.25.0

2021-09-28T00:00:00+00:00

Good evening!

We released Selenide 5.25.0.

I strongly recommend you to upgrade,
because there are even more changes coming with next releases, including the full release of Selenium 4.
If you don’t upgrade now, it will be much more difficult to clear the rubble later!

This is quite a big release with a bunch of changes, so grab some popcorn and make some tea. Let’s go!

Support for Selenium Webdriver 4.0.0 RC1
Support for OpenTest4j
Stacktrace below every error in soft asserts
Added method $.shadowRoot()
Added method $.ancestor()
Enriched methods $.closest() and $.ancestor()
Fixed method $.screenshot() on Mac
Now Selenide reports an exact text at the moment of test failure
We now forbid an empty argument in method $.matchText("")
Check webdriver().shouldHave(title(...))
selenide-selenoid 1.2.0
selenide-appium 1.7.0
Selenide downloads statistics
Selenide anniversary

Support for Selenium Webdriver 4.0.0 RC1

We released two builds of Selenide 5.25.0: regular and hipster one.
You can pick:

either	`com.codeborne:selenide:5.25.0`	(with `Selenium 3.x`),
or	`com.codeborne:selenide:5.25.0-selenium-4.0.0-rc-1`	(with `Selenium 4.0.0 RC1`).

We added support for OpenTest4j

If you haven’t heard yet, OpenTest4j is a small library for assertion errors created by JUnit 5 team. The idea is that:

all testing frameworks should throw these errors, and
all IDEs should support them.

Yet another standard, like webdriver. :) All major players like JUnit, TestNG, AssertJ, IDEA and Eclipse already supported opentest4j, and now does Selenide too.

What will change for you personally:
When your UI fails (well, almost always), IDEA will show a nice link <Click to see difference> below. By clicking it you can view a nice DIFF in a separate IDEA dialog. Very convenient for debugging.

See issue 969 and PR 1545.

NB! If you use directly some of Selenide assertion errors (inherit or throw), you will need to update your code a bit.
We slightly change signature of their constructors:

flipped “expected” and “actual” arguments
removed unneeded “driver” argument from most constructors

Now we show stacktrace below every error in soft asserts

Until now, Selenide soft asserts showed only one stack trace in the end of all errors. It allows to keep the total error message (relatively) short.
But in practice it’s convenient to see a separate stacktrace for every error. It allows to quickly click the needed line and get to the right place in the code.

Now you will see separate under every error. I personally don’t like that the error message has become much longer, but usually there shouldn’t be too many of errors, right? ;)

See issue 1543 and PR 1545

We added method `$.shadowRoot()`

Until now, you could only search elements inside of shadow root, and now you can get the shadow root itself.
Though, there is still little benefit from this because search within this element is not supported (by browsers or web drivers, I am not sure).

See issue 1515 and PR 1517.

We added method `$.ancestor()`

It’s an alias for existing method $.closest(). The name closest was originally from JQuery (which is old!), while ancestor should be more clear because it’s a standard XPath term.

See issue 1556.
Thanks to Oleg Berezhnoy for PR 1567.

We enriched methods `$.closest()` and `$.ancestor()`

Until now, this method could only search element by tag or class name:

$.ancestor("table").shouldBe(visible)
$.ancestor(".form").shouldBe(visible)

Now it can search by attributes:

$.ancestor("[argument-name]");
$.ancestor("[argument-name=argument-value]");

Thanks to Vitali Plagov for PR 1554

We fixed method `$.screenshot()` on Mac

For a long time, Selenide has method $.screenshot() to take screenshot of some element (instead of a full screen).
We found that this method worked incorrectly on MacBooks because of Retina display.

Now we remove the incorrect custom code from Selenide and started using a standard webdriver method that was created meanwhile. We checked it works in at least Chrome, Firefox and Edge.

See issue 1571 and PR 1576.

Now Selenide reports an exact text at the moment of test failure

Wow, what old issues we sometimes fix! This ticket was registered already on September 6, 2015!

In general, the story is like this.

Let’s assume you have a check in test:

$.shouldHave(text("Hello"));

And a standard timeout 4 seconds. Here is one possible scenario:

during 4 seconds, Selenide checks the element text, but it’s wrong all the time (say, “Goodbye”).
timeout expires,
selenide decides to throw an assertion error,
composes an error message, including actual element text.
at this moment the element text changes. Say, to “Hello”.

It happens very rarely, but when it happens, it may confuse a lot.
You are seeing an error message and feel totally confused:

Text didn’t match. Expected text: “Hello”, actual text: “Hello”.

Now Selenide remembers exactly the text at the moment of last check and appends it to the error message.

P.S. In next releases, we are going to improve this mechanism even more. We will show the history of element texts during those unfortunate 4 seconds. It may help debugging some tricky cases with flaky tests etc.

See issue 217 and PR 1566.
Thanks to Pavel Fokin for PR 1313.

We now forbid an empty argument in method `$.matchText("")`

There is a method for checking element text with a regular expression:

$("#child_div1").should(matchText("Tallin{1,2}")));

We found that it was possible to occasionally pass an empty string to matchText which might cause false-positive tests.
Now you will see an exception when trying to execute $.should(matchText(""))):

java.lang.IllegalArgumentException: Argument must not be null or empty string

See PR 1566

We added check `webdriver().shouldHave(title(...))`

As usually, you can use it with default or custom timeout:

webdriver().shouldHave(title("Login page"));
webdriver().shouldHave(title("Login page"), ofMillis(10));

See issue 1573.
Thanks to Ervīns Patmalnieks for PR 1579.

selenide-selenoid 1.2.0

We released selenide-selenoid:1.2.0 with upgrade to Selenide 5.25.0.

selenide-appium 1.7.0

We released selenide-appium:1.7.0 with upgrade to Selenide 5.25.0.

Selenide downloads statistics

The milestone has been passed: we exceeded 250 thousand downloads per month.

Selenide anniversary

By the way, we have come close to another significant milestone: in October, Selenide will be … 10 years old!
It’s hard to believe, but the first commit was made in the repository on October 25, 2011. Just look how ridiculous it was! :)

Andrei Solntsev

selenide.org

Released Selenide 5.24.0

2021-08-29T00:00:00+00:00

On August 29, 1997 a computer system Skynet became self-aware and launched nuclear missiles at Russia. So the war between humans and terminators began.

It happened .. oh, my god! - 24 years ago. We live in the Future, and we are still alive. And we still rule the machines.

I I celebrate this day every year, and today, in honor of the holiday, we released Selenide 5.24.0.

We added method `$.execute(Command, Duration)`

to run custom commands with a custom timeout.

In Selenide 5.3.0 we added method $.execute() for running custom commands. But it could only use a default timeout. Now you can use custom timeout for any custom command.

See issue 1525.
Thanks to Evgenii Plugatar for PR 1531.

Methods `$.execute(Command)` and `$.execute(Command, Duration)` don’t pass arguments to the command

It’s a small change, but it might break your custom commands if you have some. Be prepared.

See issue 1527.
Thanks to Evgenii Plugatar for PR 1535.

We fixed `Or` and `And` conditions in case if element is not found

See issue 1534.
Thanks to Evgenii Plugatar for PR 1539.

Now `Or` and `And` don’t accept empty conditions list

I hope you never tried to use Or and And with an empty conditions list because it makes no sense. Anyway, now you will get a runtime exception if you try to.
Thanks to Evgenii Plugatar for PR 1542.

We renamed methods `Condition.applyNull()` and `CollectionCondition.applyNull()`

Many years ago I named it applyNull, but this name is very misleading.
This method checks if the condition is met if the element is not found at all. Now it’s named missingElementSatisfiesCondition() - a rather long, but accurate.

See issue 1541.
Thanks to Evgenii Plugatar for PR 1544.

We removed useless stacktraces when closing the webdriver

As you know, Selenide automatically closes the webdriver when it’s not needed anymore. To make it possible, Selenide runs a few background threads which monitor the webdriver status. And sometimes these threads compete with each other and try to close the webdriver which has been already closed by another thread. You might see such stacktraces in your logs.

Now Selenide detects such situation better and doesn’t print long useless stacktraces.

See issue 1467 and PR 1540

We fixed searching shadow roots inside of web elements

See issue 1532 and PR 1536

selenide-selenoid 1.1.5

We released selenide-selenoid:1.1.5 with upgrade to Selenide 5.24.0

selenide-appium 1.6.8

We released selenide-appium:1.6.8 with upgrade to Selenide 5.24.0

UPD: Selenide 5.24.1

WebDriverManager is a library (used by Selenide) for downloading webdriver binaries. They recently released a major update 5.0.0 with lots of new features. We haven’t incorporated these new features in Selenide yet, but at least we released Selenide 5.24.1 with upgrade to WebDriverManager 5.0.1.

Thanks to Anil Kumar Reddy Gaddam for PR 1531.

UPD: Selenide 5.24.2

We found that commons-lang3 dependency (used by Selenide) doesn’t come transitively from WDM 5.x anymore. We had to add it explicitly and release Selenide 5.24.2.

See issue 1551.

UPD: Selenide 5.24.3

We upgraded to WebDriverManager 5.0.2, now we could exclude docker-java and few other dependencies.

UPD: Selenide 5.24.4

We upgraded to WebDriverManager 5.0.3 which had a quickfix for the latest Firefox 92.0 on MacOS.

News

The World doesn’t consist of only Web and Mobile!
You can also use Selenide for testing Swing applications! Here is an example.
Under the hood it uses webdriver implementation for swing.

Selenide usage statistics

249+ thousands of downloads per month. We almost got 250K!

Hasta la vista, baby!

Andrei Solntsev

selenide.org

Released Selenide 5.23.0

2021-07-16T00:00:00+00:00

Good summer day!

We released Selenide 5.23.0 on July, 16.

It introduces a fundamentally new feature in Selenide:

The new generation checks

Now Selenide has checks not only for web elements, but for some other elements too. You can apply those checks with built-in waitings, readable error messages, reports etc. Everything you like.

See issue 1442. Thanks to Dmitriy Budim for launching this whole epic in PR 1478.

Let’s look at these checks.

Checks for URL

Until now, there were 2 methods in Selenide to get an URL of a current page or frame (in most cases it’s the same value).

  String url1 = WebDriverRunner.url();
  String url2 = WebDriverRunner.currentFrameUrl();

Though, it was not clear how to check them or wait for a right url.

Now we have such checks:

import static com.codeborne.selenide.Selenide.webdriver;
import static com.codeborne.selenide.WebDriverConditions.*;

webdriver().shouldHave(url("https://auth.google.com"));
webdriver().shouldHave(url("https://mastercard.ee"), Duration.ofSeconds(42));
webdriver().shouldNotHave(url("http://yandex.ru");
webdriver().shouldNotHave(urlStartingWith("ftp://"));
webdriver().shouldHave(currentFrameUrl(baseUrl + "/login.html"));
webdriver().shouldHave(currentFrameUrlStartingWith(baseUrl + "/logout.html"));

Every of these checks:

waits up to 4 seconds (by default) if needed
appears in a report (text report or Allure)
takes a screenshot and throws a readable ConditionNotMetException if the url is not as expected after 4 seconds.

In the best traditions of selenide, you can

override the default timeout (4 seconds) to any other number, e.g. Configuration.timeout = 8000;
set a custom timeout for every check (as a second parameter like Duration.ofSeconds(42))
create custom checks (see example)

Checks for clipboard

Starting from version 5.20.0, Selenide has a method for accessing the clipboard:

Clipboard clipboard = Selenide.clipboard();

But you could only get or set text to the clipboard:

String foo = clipboard().getText();
clipboard().setText("bar");

Now you can also check the clipboard content. Again, with automated screenshots, reports, etc.

clipboard().shouldHave(content("Hello fast World"));
clipboard().shouldHave(content("Hello slow World"), Duration.ofMillis(1500));

See PR 1507

Checks for `localStorage`

Starting from version 5.15.0, Selenide has method localStorage() which return JavaScript object LocalStorage.
But it had only methods getItem and setItem. Again, it was not clear how to check them or wait for an item in the local storage.

Now it’s clear:

localStorage().shouldHave(item("cat”));
localStorage().shouldHave(itemWithValue("mouse", "Jerry”));

By the way, we also added method localStorage.getItems() returning all the content of localStorage as a map.

See example of custom condition in Selenide tests.

See PR 1502

Checks for `sessionStorage`

The same as for localStorage - we added methods

sessionStorage().shouldHave(item("cat”));
sessionStorage().shouldHave(itemWithValue("mouse", "Jerry”));
Map<String, String> items = sessionStorage.getItems();

See PR 1502

A small refactoring

We made classes StaticConfig and StaticDriver non-public.
It seems they shouldn’t be needed outside of Selenide. Do you occasionally use them in your project? Contact us if you are sure you need them.

And a small bugfix:

Now method Selenide.screenshot("filename") (again) takes a screenshot even if setting Configuration.screenshots is false.

Let me clarify.

You can set Configuration.screenshots to false if you need to disable automated screenshots in case of test failures (actually, I don’t really see any reasons to do that).
You can use method Selenide.screenshot("filename") to take a screenshot at any moment you wish. Independently if the test status (I also don’t really see any reasons to do that:))

The point is that method #2 works independently of setting #1. Now you can disable the automated screenshots and only take screenshots explicitly where needed (though, I still don’t see any reasons why it should be a good idea).

See issue 1477 and PR 1506

selenide-selenoid 1.1.4

We released selenide-selenoid:1.1.4 with upgrade to Selenide 5.23.0

selenide-appium 1.6.7

We released selenide-appium:1.6.7 with upgrade to Selenide 5.23.0

New links

Post Selenide – UI tests in minutes by Anil Kulkarni

Statistics

We crossed the line 232+ thousands of downloads per month!

Have a carefree summer!

Andrei Solntsev

selenide.org

Released Selenide 5.22.3

2021-07-05T00:00:00+00:00

Good evening!

There was a press release here that might hurt the feelings of many of our users and committers. We regret that this has happened, and we consider this publication to be our mistake, a manifestation of the unprofessionalism of certain maintainers.

So just upgrade to Selenide 5.22.3 with the most fresh and delicious bugfixes.

5.22.3 (released 05.07.2021)

#1474 add workaround for NPE in RemoteWebElement.isDisplayed() – see PR #1498

5.22.2 (released 30.06.2021)

#1493 support uploading files from inside of JAR files – see PR #1494
fix command ./gradlew - now it installs jars to a local maven repo – see PR #1489
add support for okhttp 4.9.1 – see PR #1488

5.22.1 (released 18.06.2021)

Add mime type “binary/octet-stream” to download binary files in FireFox

Have a carefree summer!

Andrei Solntsev

selenide.org

Released Selenide 5.22.0

2021-06-08T00:00:00+00:00

Good morning!

For my birthday, we made an anniversary release Selenide 5.22.0.

Let’s unbox the gift!

Now you can close an alert to download a file

Selenide has method $.download() which works by a very simple principle:

Click
Wait for a new file in a downloads folder

The problem is that some websites show an alert or some other dialog, and you need to close it to start downloading the file. Generally, you might need to perform some action to start the download process.

Now you can close the alert:

File downloadedFile = $(byText("Download me with alert")).download(
      using(FOLDER).withAction(
        clickAndConfirm("Are you sure to download it?")
      )
    );

or perform any other action:

File downloadedFile = $(byText("Download me with alert")).download(
    using(PROXY).withAction((driver, link) -> {
      // add cookies
      link.click();
      // driver.switchTo().window();
      // alert.dismiss();
      // send http request
      // call api
    }));

See issue 1479 and PR 1481.

We improved condition `textCaseSensitive`

… to support selected options in a <select> element - similar to Condition.text.

Thanks to Oleg Berezhnoy for PR 1482.

We added selectors `byTextCaseInsensitive` and `withTextCaseInsensitive`

… for finding elements by text ignoring case.

Before

Selenide has methods for finding elements by text (case sensitive) for a long time:

by the whole text: $(byText("Wake up we have a tsar again")
by substring: $(withText("we have a tsar")

These selectors are case sensitive (and use XPath 1.0 inside).

After

Now we have added similar methods, but case insensitive:

$(byTextCaseInsensitive("wake UP we have a TSAR again")
$(withTextCaseInsensitive("TSAR agAiN")

These selectors can find element by text ignoring the case.

Technical nuance

we could not implement this feature by XPath because string functions like lower-case and match were added in XPath 2.0, but all popular browsers support only XPath 1.0. That’s why we had to write a tricky JS code to walk through the DOM tree.

See issue 1380 and PR 1381.

We added method `Driver.getSessionId()`

Basically it’s needed in Selenide-Selenoid integration.

Thanks to Petro Ovcharenko for PR 1483.

We shortened default webdriver timeouts

There are two very strange timeouts inside of Selenium webdriver. I think it’s a problem that they are abnormally large. And you cannot change them.

Here are these default timeouts:

connect to a webdriver: connectTimeout = 120000 ms = 2 minutes
any webdriver request: readTimeout = 10800000 ms = 3 hours (!)

If some webdriver command hangs for whatever reason, your test will wait for 3 hours. For example, it happens when we test an Electron application and it goes to the system tray. The test tries to take a screenshot and hangs for a long time. I really don’t understand, is there anybody who thinks it’s reasonable?

In Selenide 5.22.0 we added possibility to change these default timeouts (it uses complex reflection under the hood).
And we made these timeouts fewer (though they are still too conservative in my mind):

connectTimeout = 1 minute
readTimeout = 2 minutes

Let’s consider it as a workaround and hope Selenium 4 brings a proper solution.

See PR 1433.

selenide-selenoid 1.1.3

We released an update selenide-selenoid:1.1.3 which fixes ClassCastException in some cases.

Thanks to Petro Ovcharenko for PR 10.

selenide-appium 1.6.6

We released an update selenide-appium:1.6.6 which upgrades to Selenide 5.22.0

News

Wow! Several famous guys posted their videos about Selenide.

Java champion Sebastian Daschner: Why I switched to using Selenide for UI tests
JetBrains feat. DJ Yuriy Artamonov: Modern UI Test Automation with Selenium Libraries
JetBrains post about this stream

And a couple of older materials:

Selenide review by Provectus

And for dessert, the younger generation teaches Selenide:

Andrei Solntsev

selenide.org

Released Selenide 5.21.0

2021-05-15T00:00:00+00:00

Good evening!

We have released Selenide 5.21.0.

What’s new there?

We removed duplicate screenshots for chained locators

Most of Selenide methods are chainable (aka fluent), so that you can call multiple methods in a line. Thus way you can write concise tests.

Something like

  $("table#id").$("tbody", 2).$("tr.active").$("td", 5)
    .shouldHave(text("Foo"))
    .click();

But there has been a problem with chained calls. If such a check failed, Selenide took multiple screenshots and added multiple steps to the report (incl. Allure report). One screenshot for "table#id", another for "tbody" etc.
Though it’s essentially a single step.

Though it was not critical, we have fixed this unpleasantness. Now Selenide will take one screenshot, and Allure report will contain one line.

See issue 1055 and PR 1465.

NB! We had to do quite a major refactoring, so something might go wrong. Feel free to share your feedback, let’s fix it quickly!

We added BrowserPerTestStrategyExtension

… for reopening a browser on every test.

By default Selenide reuses browser between tests (in a single thread). It’s a good idea for performance: opening a new browser takes time.
We assume you take care of the AUT state: clear cache, reset data, reload a page etc. in the beginning of every test. The exact clearing logic depends on your application anyway.

But if you really want to open a new browser in every test, Selenide provides built-in mechanism for JUnit 4, JUnit 5 and TestNG.

But we recently realized one missing feature for JUnit5. Selenide had only an extension for re-opening a browser before every test class (@ExtendWith({BrowserStrategyExtension.class}), but not test method.

Now we added such an extension. If you add @ExtendWith({BrowserPerTestStrategyExtension.class}, Selenide will open a new browser before every test method.

Don’t forget it makes your tests slower!

See issue 1448 Thanks to Anton Aftakhov for PR 1450.

We added method `$.hover()` with offset

Selenide has method $("div#123").hover() for emulating moving cursor onto given element. But this method puts cursor in the center point of the element, and you could not influence that.

Now we have overloaded method $.hover() with offset parameter. It allows you to specify how many pixels for the center point should be the cursor located:

  $("div#123").hover(withOffset(123, 122));

P.S. It seems the offset does not always work precisely. In my tests, it was located near this position plus-minus 30 pixels. Feel free to share your experience with hover!

See issue 1447 and PR 1461.

Upgraded to WebDriverManager 4.4.3

Thanks to Anil Kumar Reddy Gaddam for PR 1464 and PR 1469.

Updated javadoc of many Selenide methods

… regarding lazy loading and “not recommended” phrase.

Now javadoc has links to these wiki articles:

You will probably want to discuss these topics. Great, let’s discuss them!

See PR 1430

selenide-selenoid 1.1.2

We released update selenide-selenoid:1.1.2 with support for BasicAuth when downloading files from Selenoid containers.
See issue 8 and PR 9.

selenide-appium 1.6.5

We released update selenide-appium:1.6.5 with improved error message in iOS tests.
See issue 54.

Released Selenide 5.20.1

2021-03-23T00:00:00+00:00

Good night!

Joe Biden was asked if he thinks $$.as is a killer feature. «Mmm hmm, I do», — Biden answered.

This is a double release notes for Selenide 5.20.0 and Selenide 5.20.1.

We added operations with clipboard

Selenide.clipboard().setText("111");
assertEquals("Hello World", Selenide.clipboard().getText());

Note that clipboard doesn’t work on Linux without graphical environment.

Thanks to Dmitriy Budim for PR 1409.

NB!These methods are overridden in selenide-selenoid plugin to work correctly in Selenoid. We also released version 1.1.0 of the plugin.

We added `headless` mode for Microsoft Edge

The setting Configuration.headless worked only for Chrome and Firefox, now it also works for Edge.

(Browsers IE, Opera and Safari afaik still don’t support headless mode)

See issue 1422 and PR 1424.

We added method $$.as() for giving collection an alias

As you probably remember, we added method $.as() in Selenide 5.17.0. It allows to give an alias (human-readable name) to any SelenideElement.

Now you can also given readable names to collections:

$(By.xpath("/long/ugly/xpath[1][2][3]")).as("Login button").shouldBe(visible);
$$(By.xpath("/long/ugly/xpath[1][2][3]")).as("Login buttons").shouldHave(size(2));

See issue 1389 and PR 1431.

NB! Don’t rush with using this feature. I personally take it as a “last sort hack”.
It’s always better to see the real locator instead of a name which always may happen to be:

Deceiving
Deprecated
Misleading

It’s always better to invest your time in readable locator, method names, well-organized tests etc. This is where the real power lies.

We added collection condition `containExactTextsCaseSensitive`

Existing method $$.shouldHave(texts("a", "b", "c")) checks that the collection contains exactly these elements, and not any others. But sometimes we want a less strict check. For example, you need to check that the traded currencies list contains EUR and USD - and any others.

Now we have a method for such check:

  $$.should(containTexts("EUR", "USD"));

Thanks to Oleg Berezhnoy for PR 1426.

UPD In release Selenide 5.20.1 it was renamed to

  $$.should(containExactTextsCaseSensitive("RUB", "EUR", "USD"));

Thanks to Oleg Berezhnoy for PR 1438 and PR 1439.

Fixed the lost FirefoxOptions

In some situations some of Firefox options could be lost. Now they are not lost anymore.

See issue 1436. Thanks to Dmitriy Budim for PR 1437.

SelenideElement has several methods to find other elements:

$.findAll()
$.parent()
$.sibling()
$.preceding()
$.lastChild()
$.closest()

Such methods were logged twice: first when you call them, and second when you call another method of the the found element. Now we removed this duplication.

Thanks to Pavel Fokin for PR 1428.

Andrei Solntsev

selenide.org

Released Selenide 5.19.0

2021-02-24T00:00:00+00:00

Good morning!

You probably didn’t know, but today, February 24, is the main holiday in Estonia - Independence Day. Exactly 103 years ago, Estonia was proclaimed an independent democratic republic.

And 93 years later in Estonia, in the casemates of Codeborne company, Selenide library was born. Isn’t that a miracle?

So we dedicate our new release Selenide 5.19.0 to Independence Day.

We fixed drag’and’drop, finally!

Selenide has had method $.dragAndDropTo() for years, but de-factor it doesn’t work. Under the hood it uses Selenium mechanism Actions, and something was broken in it. It just doesn’t drag the element.

Now we added an alternative implementation using tricky JavaScript snippet. And it seems to work in all browsers. We even made it the default implementation.

// The working solution:
$("#drag1").dragAndDropTo("#div2");
$("#drag1").dragAndDropTo("#div2", usingJavaScript());

// Non-working solution using Actions (in case if you still want to give it a chance):
$("#drag1").dragAndDropTo("#div2", usingActions());

See issue 1110.

Thanks to Dmitriy Budim for PR 1412.

Appium support

We also released a selenide-appium:1.6.2 update which has method $.dragAndDropTo() overridden, so that it works on mobile devices too. See PR #53.

We fixed method `$.click(usingJavascript())` in Internet Explorer

See issue 1406 and PR 1419.

We improved description of `$$.snapshot()` collections

There is one tricky method in Selenide collections: $$.snapshot().
It takes a “snapshot” of the collection (fetches its elements only once), and doesn’t reload them from browser anymore. It may be useful to speed up your tests in case of big collections. But only if you are sure that the collection elements will not change anymore.

There was one tiny problem: such a snapshot didn’t look nice in reports. For example, this line:

$$("#root li").snapshot().shouldHave(size(3))

when failed, looked in the report like this:

List size mismatch: expected: = 3, actual: 2, collection: $$(2 elements)

The description doesn’t contain selector of the original collection, only (2 elements).

Now it also contains the selector:

List size mismatch: expected: = 3, actual: 2, collection: #root li.snapshot(2 elements)

Thanks to Pavel Fokin for PR 1402.

Added method `$.getAlias()`

It returns the same value that you set with method $.as("login button").
Normally you don’t need this method. But it may ne useful for those who generate their own reports. Who knows, probably some of you is developing an Allure killer…

Thanks to pavelpp for PR 1415.

Added “refresh” and other events to Selenide log

There is a bunch of method in Selenide that are not related to web elements (like refresh(), back() etc.) And we recently found that some of these methods were not shown in Selenide/Allure reports. Not fatal, of course, but still, someone needs these reports for some reason…

Now we fixed it, and the following actions will be added to reports:

refresh
back
forward
updateHash
confirm
dismiss
prompt
clearCookies

See issue 1383 and PR 1404.

Added `@Nullable` annotations to `WebDriverRunner` methods

Probably the most import is @Nullable annotation for method WebDriverRunner.getSelenideProxy(): it was not obvious that this method can return null if the proxy is not started.

Now such an error will be highlighted in your IDE.

See commit.

Fixed Selenide own tests on non-EN machines

Selenide user @vrossellotravelc tried to build selenide project on a machine which has a default language other than English (was it French or Spanish?)

We found that a couple of Selenide own tests contained hard-coded formatting of Duration, which can differ in other locales.

Now those tests are fixed so that it cannot happen anymore. How? Welcome to the PR!

Thanks to Vicente Rossello Jaume for PR 1408.

Statistics

The latest Selenide downloads statistics:

Traditions

That’s it for today.

While you are updating, I’m going to find a glass of vodka and a sprat sandwich.
It’s a tradition in Estonia for independence day, you know.

Andrei Solntsev

selenide.org

Released Selenide 5.18.1

2021-02-11T00:00:00+00:00

Hi all!

We have release a small update Selenide 5.18.1.

Let’s look at the changes:

Added method `Selenide.getSessionStorage()`

… similar to Selenide.getLocalStorage() added in 5.15.0.

They both have the same set of methods: getItem, setItem, removeItem, clear etc.

Sometimes it’s useful to set some flag to sessionStorage to localStorage to emulate some user action or toggle some features or settings.

Thanks to Dmitriy Budim for PR 1400.

P.S. FYI difference between localStorage and sessionStorage.

Fixed error message for `$$.filterBy(and(..))`

As you know, Selenide provides powerful API for filtering and validating collections.

User Pavel Fokin found that the error message can look misleading when the collection is filtered with and condition (a combination of other conditions):

$$(".sofa").filterBy(and("shining", text("Jorshik"), text("Zoloto"))).shouldHave(size(2));

The output was a bit misleading (because it showed only the last checked condition):

... collection: .sofa.filter(text Jorshik)

Now the output contains all conditions:

... collection: .sofa.filter(shining: text 'Jorshik' and text 'Zoloto')

See issue 1392.
Thanks to Pavel Fokin for PR 1393.

Pass “noproxy” option from user-provided proxy to Selenide proxy

As you know, Selenide can run its own embedded proxy server (used to download files, intercept requests etc.) It’s also possible to provide Selenide your own proxy. Then Selenide uses both proxies, one through the other.

Every proxy can have a setting “noproxy” which often has value “localhost”. It mean that all requests except “http://localhost:*“ should be proxied. And this setting was lost when running Selenide with two proxies, Thus Selenide could not run requests to localhost.

Now Selenide passes “noproxy” setting from your proxy to its own proxy.

Localhost is a delicate thing!

Thanks to Boris Osipov for PR 1390.

Upgraded to Netty 4.1.59.Final and LittleProxy 2.0.2

It is unlikely that you will read them, but here are the release notes for Netty 4.1.59.Final and LittleProxy 2.0.2. At lease they fixed some security issue and a memory leak.

It’s all for today. Feel free to update and share your feedback.
Create issues in github, complain in chats, swear in twitter.

Github is stronger than bugs!

Andrei Solntsev

selenide.org

Released Selenide 5.18.0

2021-01-23T00:00:00+00:00

Good evening!

Today is January, 23.

Let’s meet the new update: Selenide 5.18.0.

Let me invite you to take a small virtual tour of the changes in 5.18.0.
Make yourself comfortable.

We disabled webdriver logs by default

Starting from version 5.13.0, Selenide wrote webdriver logs to files build/reports/tests/webdriver.uuid.log.
It seemed to be useful at that moment. But later we realized that these logs take quite a lot of disk space, and nobody really needs to read them in most cases. That’s why we decided to disable them by default.

If you need those webdriver logs, you can still enable them with setting Configuration.webdriverLogsEnabled = true.

See issue 1365 and PR 1379.

Changed “timeout” parameter type from Long to Duration

… in collection methods. Now instead of

  $$.shouldHave(texts(...), 5000);

it is fashionable to write

  $$.shouldHave(texts(...), Duration.ofSeconds(5));

See issue 1377.
Thanks to Ostap Oleksyn for PR 1377.

Speed up search of inner shadow dom elements

One of features that do exist in Selenide, but not in Selenium webdriver is shadow dom:

$(shadowCss("p", "#shadow-host", "#inner-shadow-host"))
    .shouldHave(text("The Shadow-DOM inside another shadow tree"));

There might be multiple shadow roots inside of other shadow roots.
To find all elements inside inner shadow roots, method $(shadowCss()) performed a JavaScript snippet in loop for every shadow root separately. It might be slow because every call to webdriver takes time.

Now $(shadowCss()) calls one even more trickier recursive JavaScript which finds all elements in all inner shadow roots with one call.

See PR 1373.

A separate “thank you” goes to sakamoto66 for issue 1246 and PR 1233 which unfortunately was not merged, but inspired us for this optimization.

Fixed checks `$.shouldNot(and(...))` and `$.shouldNot(or(...))`

Selenide user pavelpp detected a bug in Selenide when used not in combination with and and or:

$(".lolkek").shouldNotBe(visible, ofSeconds(5));   // works
$(".lolkek").shouldNotBe(and("foo", visible));     // fails
$(".lolkek").shouldNotBe(or("foo", visible));      // fails

Now we fixed it. All three lines don’t throw errors anymore.

See issue 1369 and PR 1370.

By the way, we now forbid using and and or with only one condition. In other words, line or("foo", visible) doesn’t compile anymore. You have to use at least two condition, like or("foo", visible, enabled).

Agree, this is logical.

We detect conflict in “browserName” capability

We recently realized that there are two settings for specifying browser:

The primary - Configuration.browser
Another - Configuration.browserCapabilities["browserName"] (I don’t really know why it’s needed)

And you might get an unexpected browser opened if you haven’t set the first one, but set the second one. Now Selenide detects such a conflict and throws an exception:

IllegalArgumentException: Conflicting browser name: 'chrome' vs. 'firefox'

Let me repeat: setting Configuration.browser is enough in all cases. As far as I know, the second setting is never needed.

See issue 1366 and PR 1374.

Fixed displaying timeout parameter in reports

Recently we added to $.should* methods parameter timeout of type Duration.
Then we realized it was displayed quite unclearly in Selenide/Allure reports.

For example, line $("h1").shouldBe(visible, Duration.ofSeconds(1)) looked like this in a report:

$("h1") should be([visible, PT1M])

Though this “PT1M” is an ISO-compatible representation and means “time period 1 minute”, we decided to replace it by more familiar “300 ms”, “1s”, “1.500 s.” etc.

See issue 1376 and PR 1378.

Upgraded to WebDriverManager 4.3.1

As usually, see their changelog here.

It’s the end of our excursion. Feel free to update and share your feedback.
Create issues in github, complain in chats, swear in twitter.

News

Here is an final downloads statistics of Selenide for year 2020. Not bad!

Happy current year!

Andrei Solntsev

selenide.org

Released Selenide 5.17.2

2020-12-30T00:00:00+00:00

Good morning!

The gnomes still cannot calm down. Tomorrow morning they will bring you the last present in your socks: release Selenide 5.17.2.

Make `Commands` return `SelenideElement` instead `WebElement`

It allows you chaining $.execute(Command) with other Selenide methods, thus making your tests even more concise and expressive:

$(".lupa").execute(new ScrollToCenter()).$(".pupa").click();

Thanks to Boris Osipov for PR 1355.

Fixed method `$.setValue(null)`

See issue 1356. Thanks to Dmitriy Zemlyanitsyn for PR 1357.

Enabled soft asserts in @BeforeAll and @AfterAll methods (in JUnit 5)

See issue 981, issue 1070 and PR 1359.

Fixed file selenide-5.17.2-javadoc.jar

now it contains javadoc for all classes.

Once again, Happy New Year!

Andrei Solntsev

selenide.org

Released 5.17.0

2020-12-26T00:00:00+00:00

Good night!

I am passionate about Catholic Christmas. Because it was on Christmas that the terrorists took over the Nakatomi plaza and Bruce killed Hans Gruber. And then he blew up the plane with a lighter.

So catch the Christmas release Selenide 5.17.0.

Added method $.as(“name”)

We added method as, so that you can give elements readable names.

To feel the difference, let’s compare the following two lines in test:

  $(By.xpath("/long/ugly/xpath[1][2][3]")).shouldNot(exist);
  $(By.xpath("/long/ugly/xpath[1][2][3]")).as("Login button").shouldNot(exist);

The test result looks like this:

  +---------------------------------------+--------------------+----------+----------+
  |Element                                |Subject             |Status    |ms.       |
  +---------------------------------------+--------------------+----------+----------+
  |By.xpath: /long/ugly/xpath[1][2][3]    |should not(exist)   |PASS      |13        |
  |Login button                           |should not(exist)   |PASS      |38        |
  +---------------------------------------+--------------------+----------+----------+

In the last line, we see a readable name “Login button” instead of long unreadable xpath.

NB! Don’t rush with using this feature. I personally take it as a “last sort hack”.
It’s always better to see the real locator instead of a name which always may happen to be:

Deceiving
Deprecated
Misleading

It’s always better to invest your time in readable locator, method names, well-organized tests etc. This is where the real power lies.

See issue 1200 and PR 1353.

Added bunch of default options to headless chrome

We added the same default options to headless chrome as in Puppeteer.
We assume that Puppeteer guys are smart, so we do like them. :)

Thanks to Aliaksandr Rasolka for PR 1329.

Fixed `ByShadowCss.findElements`

It returned only subset of elements in a particular case: when DOM contained multiple inner shadow hosts.

Now it returns all the elements.

See issue 1346. Thanks to Daniel H. Peger for PR 1347.

Added $.should* methods with custom timeout

As you know, there are two major groups of methods in Selenide:

$.shouldHave / $.shouldBe / $.should – use default timeout
$.waitUntil / $.waitWhile – use given timeout

$.wait* are useful for “long” actions that last longer than the default timeout (which is 4 seconds by default).

The problem with $.wait* methods is purely grammatical: Selenide built-in conditions don’t sound correctly with verb “wait”:

element should have text - sounds right
element wait until text - doesn’t sound right

Now you can replace $.waitUntil(hasText("bob"), 18_000) by $.shouldHave(text("bob"), Duration.ofSeconds(18)).

See issue 1136, issue 1338 and PR 1340.

Page objects

The next block of improvements concerns the Page Objects.

As you know, in Selenide it’s possible to create page objects

with fields annotated with @FindBy,
which can be standard selenium WebElement,
or our SelenideElement,
or even reusable components ElementsContainer which can be used to compose more complex page objects.

And it all works in the best traditions of selenide: lazy loading and reloading of elements etc.

There were some issues with those @FindBy fields:

lazy loading didn’t work for PO fields of type List<ElementsContainer> (see issue 282 and 482)
PO fields of generic types were not supported (see issue 694)

It was hard to fix. I had to dive into (quite old) code and refactor it. I had to strain my brains and apply all my remnants of the former abstract thinking. :)

That’s why these two pull requests are my pride:

And finally, a couple of technical improvements:

split Selenide project to subprojects - see PR 1348
fixed Selenide tests that depended on OS - see issue 1344 and PR 1345, thanks to Daniel H. Peger
cleaned up Plugins code – thanks to Yuri Orlov for PR 1343
upgraded to browserup-proxy:2.1.2 and guava:30.1-jre
added support for chrome 88, edge 89, opera 73

Known issues:

file selenide-5.17.0-javadoc.jar happened to be incomplete: it doesn’t contain javadoc for some of Selenide classes. Will be fixed in 5.17.1.

Summarizing

In general, we end the year on a positive note:
performed a non-trivial refactoring and fixed several old pains.
We are entering the New Year with only one screen in github issues instead of two.

And the number of downloads of selenide has grown over the year from 102 to 167 thousand.

Happy New Year!

Andrei Solntsev

selenide.org

Released Selenide 5.16.2

2020-11-25T00:00:00+00:00

Good morning!

We released Selenide 5.16.2.

Please don’t think that recent release Selenide 5.16.0 had a lot of bugs.
Not at all.

This release 5.16.2 is a bunch of fixes for old small issues.

Briefly:

Release 5.16.2 (25.11.2020)

#1332 return old click(int, int) command logic – thanks to Petro Ovcharenko for PR #1333
make SoftAssertsExtension thread-safe – thanks to @dtuchs for PR #1334
#1258 fix soft asserts with ParameterizedTest in jUnit5 – see PR #1328
#1293 don’t report “Element not found” in case of other errors – see PR #1326
#1290 don’t show unused page object fields in report – see PR #1327
upgrade to littleproxy:2.0.1 – see PR #1325

Release 5.16.1 (23.11.2020)

Here we had two fixes to run Chrome with extensions.

#1314 do not exclude “load-extension” switch if Chrome is opened with extensions – see PR #1324
#1315 support custom DriverFactory for running remote browsers – see PR #1324

News

Once there is room left, I will share brand new links:

Example from LambdaTest: selenide-testng-sample
Video about Selenide on Portugal: Testes de Aceitação em Java com Selenide, Adriano Magalhães
Selenide course somewhere in Brazil: Automação Web Descomplicada Com Selenide
Visual testing: Applitools+Selenide
Project sample: Getting started with applitools

Stay tuned for Selenide 5.17.0!

Andrei Solntsev

selenide.org

Released Selenide 5.16.0

2020-11-20T00:00:00+00:00

Good night!

We released Selenide 5.16.0.

Plugin system

One of the major plans for this year in Selenide roadmap was to create a plugins system. It took time, but now

the day has come!

Currently there are two Selenide plugins available:

We will describe them in following posts.

Apparently, we are going to create next plugins for Allure, JUnit, TestNG, AShot.
Please share your ideas too!

See issue #1051 and PR #1264, PR 1317 and PR 1321.

Error messages

One of core Selenide functions is forming error messages in case of test failures.
Sometimes these error messages can also be incomplete or unclear, especially in some corner cases.
In this release, we did a whole bunch of fixes for error messages.

Improved error messages for AND and NOT checks

A canonical way to perform a negative check in Selenide is method shouldNotHave.
And if you want to perform multiple checks - just write them in a line using commas:

  $("#username").shouldNotHave(text("admin"));
  $("#username").shouldHave(text("____"), attribute("data-masked"));

But there are alternative methods Condition.not and Condition.and for specific cases. For example, you can declare composite conditions, thus creating DSL for your tests.

  public class MyConditions {
    private static final Condition NONADMIN = not(text("admin"));
    private static final Condition MASKED = and("MASKED", text("___"), attribute("data-masked"));
  }

  public class MyTest {
    $("#username").shouldBe(MASKED);
    $("#username").shouldBe(NONADMIN);
  }

We found that these methods showed incomplete information in test reports:

  | #username |should be(MASKED)                  |PASS |
  | #username |should have(not text)              |PASS |

The problem is that we don’t see the expected text (“admin”) and other conditions.

Now we fixed this problem, and you will see the expected text:

  | #username |should be(MASKED: text '___' and attribute data-masked)      |PASS |
  | #username |should have(not text 'admin')                                |PASS |

Thanks to Pavel Fokin for PR 1306 and PR 1306.

Added information about parents

In Selenide, you can find elements inside other elements. Like this:

  $("#user-table").$("thead").$("trrrr-chah-chah").shouldHave(text("Age"));

But if such a check failed, you could see only the child element’s locator in the error message:

  Element not found {trrrr-chah-chah}

Now we added information about its parents too:

  Element not found {#user-table/thead/trrrr-chah-chah}

Thanks to Petro Ovcharenko for PR 1312.

We added actual texts for `ownText` and `exactOwnText` checks

As you remember, in Selenide 5.15.0 we added checks ownText and exactOwnText:

  $("#child_div1").shouldHave(ownText("Sonar"));

But if such check failed, you didn’t see the actual “own text”, but only the whole element’s text with its children:

  Element should have own text 'Sonar' {#child_div1}
  Element: '<div id="child_div1">Son</div>'

Now we added “Actual value” line with element’s own text:

  Element should have own text 'Sonar' {#child_div1}
  Element: '<div id="child_div1">Son</div>'
  Actual value: Son

See issue 1261 and PR 1294.

We throw the right exception if you try to upload a wrong file

If you tried to upload a missing file:

  $("input[type='file']").uploadFile(new File("/foo/bar/xyz.pdf"));

you got an incorrect exception:

  Element not found {input[type='file']}
  ...
  Caused by: InvalidArgumentException: invalid argument: File not found : /foo/bar/xyz.pdf

Not a big deal, but sometimes is might be misleading.

Now we throw the right exception:

  InvalidArgumentException: invalid argument: File not found : /foo/bar/xyz.pdf

See issue 987 and PR 1301.

The root problem that Selenium doesn’t have dedicated exception classes for all possible corner cases. See issues 1293 for example. Also some webdriver implementations can throw non-reasonable exceptions - for example, IEDriver threw Throwable instead of ElementNotFound when I checked it last time.

That’s why we decided to use a conservative strategy in Selenide: if we couldn’t detect the problem precisely, we assume that element not found, and you will see the real problem in the “caused by” block anyway.

Show ClickOptions in the report

As you remember, in Selenide 5.15.0 we added generic methods for clicking with all kinds of options:

  $("#page").click(usingJavaScript().offset(123, 222));

And again, we found that such a line was not readably in report:

  | #page               |click(com.codeborne.selenide.ClickOptions@33617539)         |PASS |

Now we made it readable:

  | #page               |click(method: JS, offsetX: 123, offsetY: 222)               |PASS |

See issue 1302 and PR 1303.

Other changes

We added check `$$.shouldHave(exactTextsCaseSensitiveInAnyOrder(...))`

There are multiple collection checks in Selenide:

  $$(".employee").shouldHave(texts("john", "bob", "katie"));            // case-insensitive, substring
  $$(".employee").shouldHave(textsInAnyOrder("john", "katie", "bob"));  // case-insensitive, substring, any order
  $$(".employee").shouldHave(exactTexts("john", "bob", "katie"));       // case-insensitive, full string match

Now we got one more:

  // case-sensitive, full string match, any order
  $$(".employee").shouldHave(exactTextsCaseSensitiveInAnyOrder("John", "Bob", "Katie"));

Thanks to Vitali Plagov and PR 1286.

We support `href`s with special symbols

As you remember, in Selenide 5.15.0 we added check href.
But it didn’t support href values with escaped characters, like in the second line:

  $("a").shouldHave(href("/foo/bar/details.html"));    // works
  $("a").shouldHave(href("/files/some%20file.pdf"));   // fails

Now it’s fixed.

See issue 1298.
Thanks to rerednaw and PR 1299.

Allow Chrome to download multiple files

There are such tricky links that cause downloading of two or more files.
We found that Chrome shows a dialog “Are you sure you want all these files?” in this case. And this dialog blocks your test until user clicks “ok”.

The worst thing about this problem is that it is very difficult to repeat it by hand: the browser shows the dialog only the first time, so when running locally, most likely you will not see it, and the test will be green.

To fix this problem, we added an option profile.default_content_setting_values.automatic_downloads=1 when running Chrome browser. This option allows Chrome to download multiple files without any dialogs.

See issue 1307.
Thanks to Alexei Vinogradov and PR 1308.

We allow downloading files with slashes in name

Until now, method download didn’t allow a file which has slash in name:

  File report = $("#report").download();
  
  --> IllegalArgumentException("File name cannot contain slash: 11/08/2020_-_day_transactions.pdf")

It seemed logical to us, because no file system allows creating of such files.
But it turned out that sometimes the slash is quite logical - for example, as a separator in dates. And browsers can download such files. For example, Chrome simply replaces the slashes with underscores.

Now Selenide also does it.

See issue 1322 and PR 1323.

Fixed Guava version 30.0-jre

Oh, Guava!

In Selenide own code, Guava is not used. We don’t directly need it.
But many other libraries still use different versions of Guava: Selenium, LittleProxy, BrowserUpProxy, Checkstyle…

Selenide users periodically experienced problems when Maven or Gradle fetched transitively a wrong Guava version, and Selenide didn’t properly work.
We are tired of it. Now Selenide explicitly declares a dependency on latest Guava version 30.0-jre. We hope it will fix all those endless dependency issues.

We migrated to Github Actions

As in any decent project, Selenide has its own set of automated tests (unit and integration), and they run automatically for all branches on a CI server. We used to use Travis CI which provides a free service for open-source projects. Thank them very much for the years of joint work. :)

But this year, Github started their own CI service “Github actions”. It seemed reasonable to migrate to it.

Now all Selenide builds can be found right on github.

Thanks to Boris Osipov and PR 1319.

The ned

It was a long text, but you mastered it. All good fellows!

As usually, update, try, experiment and feel free to report problems and share ideas.

Andrei Solntsev

selenide.org

Why proxy does not work in Selenoid?

2020-11-17T00:00:00+00:00

Good night!

Today we will finally reveal the secret of why proxy does not often work in Selenoid.

The goal: download a file

We run tests which open browsers in Selenoid containers (usually with Selenide, but it’s not important in this case).
We want to download a file during the test.
Default method $.download() doesn’t work (for example, because the download starts by submitting a form - there is no direct link to the file).
That’s why we want to download file via proxy.

Our plan

Create a project

Add BrowserUpProxy dependency as shown in Selenide documentation:

dependencies {
  testRuntimeOnly("com.browserup:browserup-proxy-core:2.1.1")
}

Copy-paste a typical boilerplate to run browsers in Selenoid:

Configuration.proxyHost = "192.168.0.10";
Configuration.remote = "http://localhost:4444/wd/hub";
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setBrowserName("chrome");
capabilities.setVersion("85.0");
capabilities.setCapability("enableVNC", true);
capabilities.setCapability("enableVideo", true);
capabilities.setCapability("enableLog", true);
Configuration.browserCapabilities = capabilities;
Configuration.fileDownload = FileDownloadMode.PROXY;
Configuration.proxyEnabled = true;

And write a test, something like this:

open("https://the-internet.herokuapp.com/download");
File file = $(byText("some-file.txt")).download();
assertThat(file.getName()).isEqualTo("some-file.txt");

The problem

And we get an error when opening a browser:

org.openqa.selenium.WebDriverException: unknown error: net::ERR_TUNNEL_CONNECTION_FAILED
    ...
	at com.codeborne.selenide.Selenide.open(Selenide.java:49)
	at org.selenide.selenoid.FileDownloadTest.download(FileDownloadTest.java:45)

AAA, panic mode!

At this point, most people panic, go through a bunch of browser options and Selenide settings and in the end write to one of the QA chats.

But all you had to do was read the log carefully.

The problem is clearly visible in the log:

[LittleProxy-0-ProxyToServerWorker-1] ERROR org.littleshoot.proxy.impl.ProxyToServerConnection
                        - (HANDSHAKING) [id: 0xc05a41d5, L:/10.10.10.145:56103
                        - R:the-internet.herokuapp.com/52.1.16.137:443]
                        : Caught an exception on ProxyToServerConnection
java.lang.NoSuchMethodError: 'int io.netty.buffer.ByteBuf.maxFastWritableBytes()'
	at io.netty.handler.codec.ByteToMessageDecoder$1.cumulate(ByteToMessageDecoder.java:86)

Tune the dependencies

Exception NoSuchMethodError clearly says that we have a problem with dependencies: apparently, there are two JAR’s with incompatible versions in classpath.

The humanity invented a vaccine against this a long time ago. I wonder why so many people still don’t know it.

Let’s run command

gradle dependencies, or
mvn dependency:tree

And we clearly see which JAR’s have which versions. Let’s look for something similar to “netty”.

\--- com.browserup:browserup-proxy-core:2.1.1
     +--- io.netty:netty-codec:4.1.44.Final
     +--- xyz.rogfam:littleproxy:2.0.0-beta-5
     |    +--- io.netty:netty-all:4.1.34.Final

We have two jars with different versions: netty-codec:4.1.44.Final and netty-all:4.1.34.Final.

Treating dependencies

There are many ways to fix the problem. Probably the easiest one is to declare Netty versions explicitly in build.gradle or pom.xml:

testRuntimeOnly("io.netty:netty-all:4.1.54.Final")
testRuntimeOnly("io.netty:netty-codec:4.1.54.Final")

(actually it’s enough to declare just one of them. Homework for you: which one and why?)

Now command gradle dependencies shows that Netty versions are matching:

\--- com.browserup:browserup-proxy-core:2.1.1
     +--- io.netty:netty-codec:4.1.44.Final -> 4.1.54.Final
     +--- xyz.rogfam:littleproxy:2.0.0-beta-5
     |    +--- io.netty:netty-all:4.1.34.Final -> 4.1.54.Final

The test runs, proxy works, file is being downloaded. Everyone is happy.

Moral

Pay attention to the logs, our smaller brothers!

Andrei Solntsev

selenide.org

Released Selenide 5.15.0

2020-09-26T00:00:00+00:00

Hi all!

We released Selenide 5.15.0.

What’s new?

Setting Configuration.pageLoadTimeout
Click with options
File download with options
Working with LocalStorage
Element text without descedants
Speed up filtered collections
Checks for “href”
Chrome option “–no-sandbox”
News

We added setting `Configuration.pageLoadTimeout`
(default value is 30 seconds)

Sometimes your browser hands trying to load some heavy page, or a huge image or something else.
You lose your time, your build lasts for a long; sessions get expired by timeout etc.

It would be reasonable to fail test fast in this case. But the default page loading timeout in Selenium is unreasonable big: the whole 5 minutes.

That’s why we added setting Configuration.pageLoadTimeout, so that you could easily change this timeout.

NB! The default is 30 seconds. It might be too small for your application. Be aware.

See issue 1268 and PR 1269.

We added generic click method
with `ClickOptions` parameter

In a way, this is a new word in Selenide API.

Initially, Selenide has method $.click() which just called standard Selenium method WebElement.click(). Which clicks to the center of web element (I guess).

Over time, variations began to appear:

we added setting Configuration.clickViaJs to click using JS code instead of WebElement.click(). In theory, it should make your tests more stable, and maybe even faster.
we added click with offset $.click(offsetX, offsetY) to click some other point but the center of element.

But if you ever had need to click “both ways” (standard and via JS), you had to switch the global setting Configuration.clickViaJs every time. It might be inconvenient.

That’s why we added method click which accepts a “way to click” as an explicit parameter.

Now you can click in different ways without changing the global setting:

  $("#page").click(usingJavaScript());
  $("#page").click(usingJavaScript().offset(123, 222));
  $("#page").click(usingJavaScript().offsetY(222));
  $("#page").click(usingDefaultMethod());

NB! We recommend to set Configuration.clickViaJs to a value which is reasonable in most cases, and pass ClickOptions parameter only in exceptional cases.

See issue 1173.
Thanks to Dmytro Stekanov for PR 1226.

We added generic method download method
with `DownloadOptions` parameter

A similar story is about method $.download(). Initially it could only download files with GET request.
Later Selenide added possibility to download files via PROXY server. And recently we added a third way - FOLDER.
Until now, you could only select the downloading method global, via global setting Configuration.fileDownload.

Now you can explicitly set downloading mode to every call of $.download method:

  File f = $("input").download(DownloadOptions.using(PROXY);
  File f = $("input").download(DownloadOptions.using(PROXY).withTimeout(9999));
  File f = $("input").download(DownloadOptions.using(PROXY).withFilter(withExtension("xls")).withTimeout(9999));
  File f = $("input").download(DownloadOptions.using(FOLDER);
  File f = $("input").download(DownloadOptions.using(FOLDER).withTimeout(9999));
  File f = $("input").download(DownloadOptions.using(FOLDER).withFilter(withExtension("pdf")).withTimeout(9999));

NB! We recommend to set Configuration.fileDownload to a value which is reasonable in most cases, and pass DownloadsOptions parameter only in exceptional cases.

See issue 1259 and PR 1260.

We added methods to work with LocalStorage

import static com.codeborne.selenide.Selenide.localStorage;

// Delete all items from local storage:
localStorage().clear();

// Add an item to local storage:
localStorage().setItem("username", "john");

// Check item value:
assertThat(localStorage().getItem("username")).isEqualTo("john");

// Check items count:
assertThat(localStorage().size()).isEqualTo(1);

// Remove an item from local storage:
localStorage().removeItem("username");
assertThat(localStorage().getItem("username")).isNull();

Thanks to Dmytro Stekanov for PR 1274.

We added checks for element own text (without descendants)

The classical selenide check $.shouldHave(text("Hello, world")) includes text of element itself and all its children (descendants).
But sometimes you want to check only the element itself, without descendants.

Now you can use ownText check for this:

  $.shouldHave(ownText("Hello"));           // We expect element text to contain "Hello" world
  $.shouldHave(exactOwnText("Hello"));      // We expect element have text "Hello"

See issue 1261 and PR 1262.

We improved performance of big filtered collections

Selenide has convenient methods for working with collections. You can search and filter elements, you can check texts or properties of multiple elements with just one line.

But if you overuse this, you might end up with too slow tests. Like this:

ElementsCollection list = $$("li").filter(visible);   // Page has 100 <li> elements
for (int i = 0; i < 10; i++) {
  list.get(i).shouldBe(visible);
}

Assume that there is 100 <li> elements on the page. Then this test can work too slowly, because:

on each step, Selenide needs to reload the element (its state might have changed)
To reload Nth element of a collection, Selenide needs to reload the whole collection (Selenium does not have method like WebDriver.findElement(index)).
To reload a filtered collection, Selenide needs to apply the filter to all its elements (in this case, call WebElement.isDisplayed() for all 100 elements).

For comparison, this code works much faster:

ElementsCollection unfiltered = $$("li");   // Unfiltered collection 
for (int i = 0; i < 10; i++) {
  unfiltered.get(i).shouldBe(visible);
}

In this release, we improved working with collections. Now Selenide filter for collections is a bit smarter: to get list.get(N), it applies visible filter only to first <N> elements, not to all 100 elements.

See issue 1266 and PR 1270.

P.S. Let me remind you another way to speed up working with collections - method snapshot:

ElementsCollection list = $$("li").filter(visible).snapshot(); // snapshot() creates a "dump" of the collection. Selenide will not reload it  
for (int i = 0; i < 10; i++) {
  list.get(i).shouldBe(visible);
}

Method $$.snapshot() creates a “dump” of the collection. Selenide will not reload it every time.
It makes your test much faster, but there is a risk to get StaleElementReferenceException, if the collection still changes during the iteration.

We added check “href”

Sometimes you want to check that element <a> has a correct href attribute.
Selenide has a method for attribute check: $("a").shouldHave(attribute("href", "/foo/bar/details.html").

But there is a problem with links. Such a check may unexpectedly fail because Selenium returns an absolute, not a relative URL.

To address this issue, we added a special check for “href” attribute:

  $("a").shouldHave(href("/foo/bar/details.html"));

See issue 1272 and PR 1273.

We added chrome option “–no-sandbox”

We found that this option should make Chrome tests more stable. Let’s see if it helps.

See commit 3293956d

now Selenide throws an explicit error

… if it failed to create downloads folder.

See issue 1265 and commit 94ece98f.

Upgraded to WebDriverManager 4.2.2

See WDM Changelog.

News

Exactly at the moment when I was releasing Selenide 5.15.0, Hima Bindu Peteti presented Selenide on meetup:

Test Automation Made Easy Using Selenide with Hima Bindu Peteti

Andrei Solntsev

selenide.org

Released Selenide 5.14.0

2020-08-17T00:00:00+00:00

Good night!

We have released Selenide 5.14.0.

Stabilized new file downloading mode `FOLDER`

… which was introduced in Selenide 5.13.0.

What has been changed in 5.14.0:

Every time when Selenide opens a browser it creates a unique downloads folder for it.
It helps to avoid situation when parallel tests are downloading multiple files to the same folder at the same time. And it’s impossible to understand what file is downloaded by which test.

See issue 1220 and PR 1221.
- Unfortunately, it doesn’t work in IE and Safari (which don’t allow to customize downloads folder).
- It works only for browsers opened by Selenide itself.
- If you create browser by yourself, you will need to create the downloads folder and pass it to Selenide:
  - either using new method setWebDriver(driver, proxy, downloadsFolder).
  - or constructor SelenideDriver(..., downloadsFolder).
Before downloading next file, Selenide clears the downloads folder – see PR 1252
In the end of tests run, Selenide deletes all empty downloads folders – see PR 1247

Added check `$$.shouldHave(itemWithText("any text"))`

Unlike the classic check $$.shouldHave(texts("text1", "text2")), it verifies that collection contains at least one element with given text.

Thanks to Luis Serna for PR 1194.

By the way, it’s the first commit to Selenide from Bolivia! :)

Added support for Safari browser

Few years ago Selenide already had Safari support, but it seemed to work badly at that time.
At some moment, we removed the Safari support.
Now it’s the next try. This time Safari tests seem to work more or less.

As usually, you need to add just one line to run tests in Safari:

Configuration.browser = "safari"; or
-Dselenide.browser=safari

Please share your feedback.

See issue 1236 and PR 1237.

Added method `SelenideDriver.screenshot(fileName)`

It may be useful when you create “non-static” variant of driver (new SelenideDriver()) and want to take screenshots.
Now you can do it.

See issue 1166 and PR 1227.

Added method `SelenideDriver.screenshot(OutputType)`

Sometimes you need to get screenshot in Base64 format. For example, some visual comparison tools want it.

Now you can get screenshot as Base64 (or File or bytes) with new method screenshot(OutputType):

String screenshot = Selenide.screenshot(OutputType.BASE64);
byte[] decoded = Base64.getDecoder().decode(screenshot);
BufferedImage img = ImageIO.read(new ByteArrayInputStream(decoded));

See issue 1224 and PR 1231.

Now Selenide takes a screenshot when method `switchTo()` fails

As you know, Selenide automatically takes a screenshot in case of test failure.
But we found that Selenide didn’t take a screenshot if one of these methods failed:

switchTo(frame)
switchTo(window)
switchTo(alert)

Now we fixed it.

See issue 1190 and PR 1240.

Added chrome option `--disable-dev-shm-usage`

We found that without this option, Chrome might sometimes crash (because of out of memory error).

Why nobody complained about this?
Are thing better now after adding this option? Please share your feedback.

P.S. Later some people complained about this option. We are still investigating it.

Fixed Sizzle selectors on web pages containing Dojo.js, troop.js etc.

See issue 434 and PR 1242.

Made method `$.toString()` safer

See issue 1241 and PR 1245.

Improved error message when web element has disappeared

See issue 1013 and PR 1239.

Upgraded to WebDriverManager 4.1.0

See WDM Changelog.

News

Wow! Udemy course including Selenide: “What every java developer must know about software testing”
A video about Selenide in german
A project example using Selenide+Selenoid+Docker by d3m0
Another example: screenshot comparison using Selenide+Allure+Ashot+Screen Diff Plugin by Evgeniy Asovin
One more example: Selenide + Appium + Allure + TestNG by qaschevychelov
Selenide vs Selenium comparison: Choosing tools for UI testing: Selenium or Selenide? - 17.09.2019
Post by Jakub Skibiński in Sonalake company blog: Selenide: A Powerful Testing Framework - 19.06.2020
Switch from Serenity to Selenide - 22.05.2020 by Yuri Kudryavtsev (Maxilect company)

And a bunch of posts by Alexander Pushkarev:

Andrei Solntsev

selenide.org

Released Selenide 5.13.0

2020-07-08T00:00:00+00:00

Good morning!

Good summer!

We released Selenide 5.13.0.

Be prepared: it might break your tests (if they were not accurate).

Method `$.shouldHave(text(""))` now throws an exception

Probably most popular Selenide method is $.shouldHave(text("something")). But if you even use it daily, you might not realize that it checks a substring, not the whole text.

So, a check $("h1").shouldHave(text("ello")) works even for element <h1>Hello World</h1>.

A special case of this check is empty text: $("h1").shouldHave(text("")). This check is useless because any string contains an empty substring.

If you need to check that text is empty, you can use either $("h1").shouldHave(exactText("")) or $("h1").shouldBe(empty).

We want to help you overcome this typical problem and avoid useless checks. Now Selenide will throw an exception if you pass null or empty string to method text("").

I tried Selenide 5.13.0 on my current project and found 20-30 tests that failed because of this new exception.
All of this were logical errors in tests. You see what a useful change waits for you. :)

See issue 1156.
Thanks to Roman S.A. for PR 1186.

UPD
Later we added setting FULL_TEXT, that makes Selenide check the whole string, not a substring.

Removed duplicated allure logs

You might see that Selenide may log the same action twice in some cases. For example, when executing this:

  $(bySelector).findAll(BySelector).filter(condtion);

(actually this problem is not only in Allure reports, but also in usual Selenide TextReport)

Now we removed those duplicated logs. We had to refactor some code and change some other error messages, so be prepared.

See issue 997 and PR 1193.

Improved error messages for collections

Another story where we have changed error message format in case of search failure inside a collection. I hope it should be clearer now what exactly Selenide failed to find.

See issue 967 and PR 1189.

Fixed uploading of files without `<form>` tag

As you probably know, Selenide allows uploading multiple files with one command:

  $("input").uploadFile(
    new File("a.txt"),
    new File("b.txt"),
    new File("c.txt")
  );

To enable it, we once did a JS trick in Selenide.
Now it appeared that this hack required <input> to be inside of <form>. This is reasonable, but for some reason there are inputs that exist outside of <form>. Our $.uploadFile() didn’t work for them.

Now we simplified upload implementation. Now it works for any inputs and doesn’t use JS tricks.

See issue 943 and PR 1188.

Fixed downloading files with quotation marks in the name

… and other “bad” symbols.

It sounds strange, but sometimes people want to download files that have bad symbols in name (quotation marks, apostrophes etc.). Linux and Mac can save such files, but Windows cannot. Selenide method $.download() failed on Windows for such files.

Now method $.download() replaces quotation marks and other “bad” symbols in file name by underscore, as all major browsers do.

See issue 1196 and PR 1199.

Configured webdriver to write its logs to a file

Until now, webdrivers started by Selenide didn’t write their logs to anywhere. You had to enable it explicitly if you needed them.

Now Selenide enables webdriver logs by default. They are written to file like build/reports/tests/webdriver.ts_pid_tid.log.
You can get full file name from Selenide logs like this:

INFO Write webdriver logs to: /andrei/build/reports/tests/webdriver.1594248139109_18125_1.log

Read these logs next time when you need to debug some weird webdriver behaviour.

See issue 1206 and PR 1207.

Added new way of downloading files: `FOLDER`

As you probably know, Selenide has 2 options for downloading files: HTTPGET and PROXY.
See post in our blog.

HTTPGET - simple and stable. But it can only download files using links like <a href>.
PROXY - generic and powerful. But it may cause problems if you run browser remotely because it requires access from “browser machine” to “tests machine”. It often causes troubles for Selenoid and Grid users.

Now we have a third option: FOLDER.

To use it, just add this line in the beginning of tests:

Configuration.fileDownload = FileDownloadMode.FOLDER;

It’s working mechanism is very simple:

It clicks the element,
Watches for new files in folder build/downloads
If there are several new files, tries to guess which one if them suites better.

As always, you can find a working example in Selenide own tests.

P.S. We consider this option experimental by now because there are some nuances:

It works well on local run with single browser, but
During parallel run, multiple browsers might download their files into the same folder, and then Selenide might pick a wrong file.
During remote run, this option doesn’t work at all. Tests are on machine A, but browser and files are on machine B.
Currently only Chrome, Firefox, Edge, Opera are supported. But IE and Safari are not: they don’t allow to configure the downloads folder.

We will work on those nuances. Please share your thoughts on how can we solve them.

See issue 1212, PR 1213 and PR 1215.

UPD Later we improved method FOLDER, and now you can safely use it in your projects.

Method `$.getWrappedElement()` waits for the element. Again.

Probably it doesn’t affect you, but I have to mention it. Essentially, we reverted one recent change (made in Selenide 5.11).

Assuming you have the following code:

SelenideElement button = $("button");
executeJavascript("arguments[0].click()", button);

where button is shown with a delay.

Selenide always waits for this button to appear, and only then executed the JS code.
In Selenide 5.11 we did a change, so that Selenide didn’t wait for the button anymore.
It could break some tests which occasionally relied on that behaviour.
Now we restored that old behaviour: Selenide waits for the button again before executing JS code.

See issue 1191 and PR 1203.

Upgraded to BrowserUpProxy 2.1.1

Just in case

Upgrade. Try. Share you feedback.

Statistics

And here is my favorite part: latest Selenide downloads statistics.
We hit the line 160 thousands per months!

and 31+ thousands of unique IPs:

Life is good!

Andrei Solntsev

selenide.org

Released Selenide 5.12.2

2020-05-29T00:00:00+00:00

Hi all!

We have published one more mini-release Selenide 5.12.2.

Fixed annotations @Nonnull

… for some of SelenideElement methods.

After upgrading to Selenide 5.12.0 some Kotlin users started getting compilation errors in their projects.
It’s because we marked all methods of SelenideElement with annotations @Nullable/@Nonnull, and Kotlin is sensible to them.

For the following methods we now changed @Nullable annotation to @Nonnull (because they never return null):

$.getText()
$.text()
$.innerText()
$.innerHtml()
$.getSelectedText()

Now you can again put results of those methods to non-nullable variables (though such constructs seem to me a bit strange in tests).

See issue 1179 and PR 1181.

Fixed setting `holdBrowserOpen=true`

This setting didn’t work sometimes.
No we fixed it.

See issue 1172 and PR 1176.

News

Wow!

It happened!!!

We published Selenium IDE plugin which can export code to Selenide.

We will publish a separate post soon on this topic.

Huge thanks to Dmytro Stekanov for this historical moment for Selenide!

Andrei Solntsev

selenide.org

Released Selenide 5.12.1

2020-05-25T00:00:00+00:00

Good night!

This is a quickfix release Selenide 5.12.1 with a couple of minor fixes for Selenide 5.12.0

Fixed Concurrent modification exception during webdriver initialization

See issue 1170 and PR 1171.

Fixed merging of “excludeSwitches” settings of different types

It appeared that setting excludeSwitches can have either Array or List type:

  chromeOptions.setExperimentalOption("excludeSwitches", new String[]{"enable-automation", "load-extension"});
  chromeOptions.setExperimentalOption("excludeSwitches", asList("enable-automation", "load-extension"));

Selenide 5.12.0 crashed if both of types were used. Now we fixed it.

See issue 1169 and PR 1174.

News

We published Selenide Roadmap. Feel free to share your feedback!
Vide from pro:TEST meetup - Czech, 28.04.2020
Video from QA meetup - Slovak, 12.05.2020

Andrei Solntsev

selenide.org

Released Selenide 5.12.0

2020-05-23T00:00:00+00:00

Good day!

Yes! We released Selenide 5.12.0.

Most of the changes are about browser capabilities.

We fixed an old problem with `Configuration.browserCapabilities`

People had been complaining for years about ChromeOptions: some of these settings could be lost in some circumstances.
It was caused by an old bug in Selenium webdriver, which seems to be lost and forgotten.

But it seems that we have found a simple workaround for this problem.

If it helped you - please share you feedback.
If it didn’t help - please register a github issue. We will work out another hack. :)

See issue 676, issue 1097 and PR 1155.

Special thanks to those experiments that didn’t get to the release, but inspired it:

Thanks to Boris Osipov for PR #1103
Thanks to SeleniumTestAB for PR #1095

We disabled to annoying dialog “save password?”

See issue 1133 and PR 1134.

We adeed “mobile emulation” mode in grid

Since Selenide 5.6.1, you can run Chrome in “mobile emulation” mode:

java -Dchromeoptions.mobileEmulation="deviceName=Nexus 5"

Recently we found that this option only works when running Chrome locally, and was not passed to the remote Chrome.
Now we fixed it: when running Chrome in Grid, we pass all options that are used for local Chrome (except “downloads folder”).

See issue 1109 and PR 1163.

We simplified Firefox setup: now without profile

When opening a Firefox browser, Selenide created a new profile (FirefoxProfile) - at least to set a “downloads folder” setting.
Recently we found that using profile causes some limitations, and generally is not needed (I guess profile was needed for the legacy firefox driver).

Now we don’t create a profile by default.

Instead, we set downloads folder via firefoxOptions.addPreference("browser.download.dir").
We only create profile if you set some system settings starting with "firefoxprofile.".

See issue 1139 and PR 1165.

We set `"ACCEPT_INSECURE_CERTS"` setting for chromium-based Edge versions

Starting from some version, IE and Edge browser stopped supporting "ACCEPT_INSECURE_CERTS" setting
(which enables self-signed SSL certificates). So we removed this setting for IE and Edge (starting from Selenide 5.9.0).

Recently we found that latest versions of Edge browser (which are built on Chromium engine) do support this setting.
So we set "ACCEPT_INSECURE_CERTS" again for Edge 75 and newer.

NB! Selenide can know Edge version only if EdgeDriver was downloaded with WebDriverManager (which is enabled by default in Selenide).

See issue 1093 and PR 1167.

We upgraded to WebDriverManager 4.0.0

Support for Firefox 76
Support for Edge 81, 83, 84
Upgraded Apache HttpClient from 4.x to 5.0

See PR 1149 and WDM Changelog.

We upgraded to browserup-proxy-core:2.1.0

Just in case.

We fixed name of screenshot folder ‘emptyMethod’

This issue was specific to JUnit 5.

Thanks to Denis Gaievsky for PR 1138.

Annotated most of the public Selenide methods with `@Nullable` and `@Nonnull`

It will help IDEA (and hopefully other IDEs) to better highlight issues in your tests.
It will also help Kotlin users to use nullable/non-nullable types.

Again, thanks to Yuriy Artamonov for PR 1140 and PR 1144!

News

We published Selenide Roadmap. Feel free to share your feedback!
Vide from pro:TEST meetup - Czech, 28.04.2020
Video from QA meetup - Slovak, 12.05.2020

Andrei Solntsev

selenide.org

Released Selenide 5.11.1

2020-04-21T00:00:00+00:00

Good evening!

It seems that Selenide 5.11.0 still broke too many rules, and we decided to slow down the horses.

If you are affected, you can upgrade to Selenide 5.11.1.

SLF4J

Some folks didn’t like the fact that Selenide 5.11.0 requires a valid slf4j dependency. Folks don’t want to bother with slf4j. Folks don’t want to read our logs. :)

It was unexpected for us, but well, we found a compromise.

Now Selenide doesn’t require slf4j always, but only when it’s needed for sure. Namely, when you use TextReport feature.

because we can!

In Selenide 5.11.0 we introduced one small issue. Namely,

$("blah").shouldNot(exist) - passes (it’s ok)
$("blah").shouldNot(exist.because("we can")) - fails (it’s not ok)

Word because happened to be incompatible with negation. Now we fixed it, and both lines are passing.

See issue 1130 and 1131.

Dropped 16 megabytes

It appears that Selenide had one huge 16 megabyte sized file checker.jar among its dependencies.
Now we removed it.

Thanks to Yuriy Artamonov for PR 1128.

News

I will present Selenide on Czech meetup [pro:]TEST! next Tuesday, 28.04.2020.
This is an online event, so everybody can participate for free. You can call your friends who is not familiar with Selenide yet!

Language: English
Date: 28.04.2020, 18:00 GMT+2
Level: rather for beginners
Links: Announcement / Live stream

See you online!

Andrei Solntsev

selenide.org

Released Selenide 5.11.0

2020-04-19T00:00:00+00:00

Good night!

We have released Selenide 5.11.0.
This is the second quarantine release of Selenide in which we made a couple of breaking changes.

Changed the behaviour of `shouldNot*` methods for unexisting elements

Just look at the table below to understand what changed.
Assuming element h1 does not exist on a page:

Check	Selenide 5.10-	Selenide 5.11+
`h1.shouldNot(exist)`	ok	ok
`h1.shouldNotBe(visible)`	ok	ok
`h1.shouldBe(hidden)`	ok	ok
`h1.shouldNotHave(text("foo"))`	ok	FAIL
`h1.shouldNotHave(attribute("bar"))`	ok	FAIL
`h1.find("h2").shouldNot(exist)`	ok	ok
`h1.find("h2").shouldNotHave(text("foo"))`	ok	FAIL

Previous logic

A long time ago it was decided in Selenide: the check h1.shouldNotHave(text("foo")) should not fail. If the element <h1> does not exist, then it doesn’t have text “foo”. So, the condition “should not have text” is true.

Additionally, it seemed to be reasonable because the check h1.shouldNotHave(text("foo")) is the opposite to h1.shouldHave(text("foo")) which fails for an unexisting element.

New logic

But we realized that there was a problem with the previous approach: it allowed to make a mistake too easily. Namely, you could accidentally write a wrong locator, thus making a false-positive test. Test that was green, but didn’t check anything.

Now both h1.shouldHave(text("foo")) and h1.shouldNotHave(text("foo")) fail if <h1> is not found.

See issue 368 and PR 1116.

Now Selenide fails if SLF4J is not configured

If you get such an error:

java.lang.IllegalStateException: SLF4J is not configured. You will not see any Selenide logs. 
  Please add slf4j-simple.jar, slf4j-log4j12.jar or logback-classic.jar to your classpath. 
  See https://github.com/selenide/selenide/wiki/slf4j

don’t be afraid: just do what it says. It’s easy.

What problem we tried to solve?

The problem is: if you don’t have any SLF4J implementations in your project, you could miss some important Selenide logs, including “text report”. Now you are forced to include some of SLF4J implementations.

See issue 1114 and PR 1115.

Added method for partially checking the attribute value

Until now, Selenide had 2 methods for checking attributes:

presence of attribute, and
exact value of attribute:

  $("#domain-container").shouldHave(attribute("class"));
  $("#domain-container").shouldHave(attribute("class", "container"));

Now we added method attributeMatching for partially checking attribute value.
See examples in tests:

@Test
void canVerifyAttributeMatching() {
  $("#domain-container").shouldHave(attributeMatching("class", "contain.*"));  // class="container"
  $("#domain-container").shouldHave(attributeMatching("class", ".*tainer"));
  $("#domain-container").shouldHave(attributeMatching("class", ".+tain.+"));
}

See issue 996.
Thanks to Dmytro Stekanov for PR 1100.

Added method for getting the last screenshot

We added 2 new methods:

Screenshots.getLastThreadScreenshot() - returns the last screenshot taken in current thread
Screenshots.getThreadScreenshots() - returns all screenshots taken in current thread

Most of the users do not need those methods: Selenide adds screenshot details to error message anyway.
But those methods can be useful for those who write their own frameworks on top of Selenide or integrate Selenide with frameworks like Allure.

See issue 1029.
Thanks to Dmytro Stekanov for PR 1125.

Added annotation `@CheckReturnValue` to most of Selenide methods

It allows IDE (at least Intellij IDEA) to better analyze your tests and show warnings if you called some Selenide method, but forgot to check results:

Thanks to Yuriy Artamonov for PR 1106.

Added missing method `Selectors.byTagName()`

Just for consistency with By methods.

Thanks to Yuriy Artamonov for PR 1104.

Fixed screenshot URL

… in case when project is run in Jenkins, and the project path contains spaces.

See issue 1072.
Thanks to Dmytro Stekanov for PR 1098.

Disabled annoying warnings about Chrome extensions

Some folks saw those annoying warnings in Chrome:

Now we disabled them with this setting:

options.setExperimentalOption("excludeSwitches", new String[]{"enable-automation", "load-extension"});

Please let us know if it causes some problems in your projects.

See issue 1119 and PR 1120.

Now you can set `selectorMode` and `assertionMode` via system properties

… Just for consistency with other Selenide settings.

See commit 231597eb6229e.

Method `$.getWrappedElement()` doesn’t wait anymore

I guess most of you didn’t even know about this method.
A long time ago, it was added to give access to the original Selenium WebElement without any Selenide magic (just in case, if somebody should need it).
But Iakiv Kramarenko noticed that it still applies Selenide magic: method $.getWrappedElement() waited for presence of the WebElement.

Not it doesn’t wait anymore. If the element doesn’t exist - you will get org.openqa.selenium.NoSuchElementException.
And yes, you can also get the legendary StaleElementReferenceException.

See issue 1015 and PR 1124.

Statistics

And here is my favorite part: latest Selenide downloads statistics. We hit the line 130 thousands per months!

and 23 thousands of unique IPs:

Life is good!

Andrei Solntsev

selenide.org

Released Selenide 5.10.0

2020-03-18T00:00:00+00:00

Good quarantine!

It was the third day of quarantine.

To make you feel not so lonely, we released Selenide 5.10.0 with a bunch of improvements. Some of them are even slightly backward incompatible. Well, so you do not get bored in your dens.

Added support for Shadow DOM
Don’t fetch BrowserUpProxy by default
Replace Guava APIs by Java APIs
Made Selenide Allure report nicer
Added condition shouldBe(image)
Videos

We added support for Shadow DOM

See examples in tests:

$(shadowCss("#anyButton", "#shadow-host")).click();

$(shadowCss("p", "#shadow-host")).shouldHave(text("Inside Shadow-DOM"));

$(shadowCss("p", "#shadow-host", "#inner-shadow-host")).shouldHave(text("The Shadow-DOM inside another shadow tree"));

Firefox: Calling setValue("text") / val("text") on an input field will result in an error, saying that the element is “not reachable by keyboard”.
Temporary workaround for now is to use fastSetValue=true:

Configuration.fastSetValue = true;
$(shadowCss("input", "#shadow-host")).setValue("test");

See issue 1014.
Thanks to Dmytro Stekanov for PR 1090.

Selenide does not fetch BrowserUpProxy by default

Taking those two facts into account:

Selenide fetches BrowserUpProxy and all its transitive dependencies - it’s about ~17MB in total.
Most of Selenide users (I guess) do not use Selenide proxy.

we decided to avoid fetching those 17 megabytes by default.

The dependency

Those of you who wants to use proxy just need to add a dependency to your project:

testRuntime 'com.browserup:browserup-proxy-core:2.0.1'

(many of you already have it anyway).

Don’t worry if you forget to add the dependency - you will see a clear error message like this:

java.lang.IllegalStateException: Cannot initialize proxy. Probably you should add BrowserUpProxy dependency to your project.
    at com.codeborne.selenide.drivercommands.CreateDriverCommand.createDriver(CreateDriverCommand.java:44)
    ...
    at com.codeborne.selenide.Selenide.open(Selenide.java:41)
caused by: java.lang.NoClassDefFoundError: com/browserup/bup/BrowserUpProxy

See issue 1021 and PR 1094.

UPD 12.03.2023 Nowadays we don’t need to add that dependency anymore. Just use com.codeborne:selenide-proxy instead of com.codeborne:selenide. It will add all needed dependencies automatically.

Just in case

Probably you feel curious who eats those 17 megabytes? Here they are.
This is the list of files that should disappear from your project. The list is impressive, right?

animal-sniffer-annotations-1.17.jar
barchart-udt-bundle-2.3.0.jar
bcpkix-jdk15on-1.62.jar
bcprov-jdk15on-1.62.jar
browserup-proxy-core-2.0.1.jar
browserup-proxy-mitm-2.0.1.jar
checker-qual-2.5.2.jar
dec-0.1.2.jar
dnsjava-2.1.9.jar
error_prone_annotations-2.2.0.jar
failureaccess-1.0.1.jar
guava-27.1-jre.jar
jackson-annotations-2.9.9.jar
jackson-core-2.9.9.jar
jackson-databind-2.9.9.1.jar
javassist-3.25.0-GA.jar
javax.activation-api-1.2.0.jar
jaxb-api-2.3.1.jar
jcl-over-slf4j-1.7.28.jar
jsr305-3.0.2.jar
jzlib-1.1.3.jar
listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar
littleproxy-2.0.0-beta-5.jar
netty-all-4.1.39.Final.jar

Migrated Guava API to corresponding Java API

We just changed

com.google.common.base.Predicate from Guava
to java.util.function.Predicate from Java 8

and removed Guava dependency. It was great (until Java 8 was released), rip.

If you occasionally implemented your own CollectionCondition, you will need to rename apply to test. It must be easy.

See issue 1091.
Thanks to Wladimir Schmidt for PR 1091.

We made Selenide Allure report a little nicer

We actually just added quotes around selectors in the Allure report.
Now you can copy selectors from the report and paste into browser’s developer console (though, I cannot imagine why somebody should do it).

See issue 1032.
Thanks to Dmytro Stekanov for PR 1092.

We added condition `$("img").shouldBe(image)`

You can use it to check that image was successfully loaded.

See examples in tests:

$("#valid-image img").shouldBe(image);
$("#valid-image").shouldNotBe(image);
$("h1").shouldNotBe(image);

See issue 1069.
Thanks to Dmytro Stekanov for PR 1086.

We fixed find element by attribute which contains quites

For some reason, people sometimes put quotes inside attributes.
When trying to find an element by such an attribute, Selenide generated an invalid CSS locator.
Now we fixed it.

See issue 1060.
Thanks to Denys Lystopadskyy for PR 1062.

Videos

Did you think that probably SeleniumCamp 2020 is The Last Conference on Earth?

Because of quarantine, they have published all SeleniumCamp 2020 videos.

Among others, this playlist contains my 3 videos (sorry, they are in Russian):

Andrei Solntsev

selenide.org

Released Selenide 5.9.0

2020-03-10T00:00:00+00:00

Buenos Marchos!

In Selenide, we strive to cure flaky tests all the time.

Today we released Selenide 5.9.0 with one feature that can help to overcome some of your flaky tests.

We added a filter for downloading files: `$.download(FileFilter)`

Problem

When downloading files via proxy, Selenide can sometimes download a wrong file.
This is how it works: Selenide clicks the “download” button and intercepts all responses from server to browser.

Exactly at this moment there could happen some unrelated requests between browser and server.
Say, chrome decides to check for updates at this moment. Or your AUT sends request to google analytics. Or just some background requests.
This creates fertile ground for emergence of flaky tests which work on your machine but sometimes fail on jenkins.

Solution

To avoid such collisions, you can now explicitly specify which file you expect. Out of the box, there are filters by file name or extension. And you can create your own FileFilter implementations with any filters you need.
Given such a filter, Selenide will select the right response matching your criteria.

See examples in tests:

File f1 = $("#downloadMe").download(withName("hello_world.txt"));
File f2 = $("#downloadMe").download(withNameMatching("hello_.\\w+\\.txt"));
File f3 = $("#downloadMe").download(timeout, withExtension("txt"));

See issue 1065 and PR 1080.

We fixed error when starting IE 3.150

See issue 1061.
Thanks to Boris Osipov for PR 1075.

We fixed error when starting Microsoft Edge

See issue 1039.
Thanks to Boris Osipov for PR 1084.

News

A funny dialog in Twitter: contributor of Selenium and Watir projects Titus Fortner admitted that he watched my presentation about Selenide on SeleniumConf, and even stole some ideas for Watir. And I admitted that some of Selenide ideas were initially stolen from Watir. :)
A good article Modern Best Practices for Testing in Java. A plenty of right ideas.
A post Selenide Test Automation: Using Selenoid in the Docker Container
A post Parametrized UI testing with Selenide and Junit 5
Some base project qa-automation-base which has mixed Kotlin + Selenide/Appium + JUnit 5 + Allure + Allure EE + TestRail.

Statistics

And for dessert - Selenide download statistics. We are growing!

Andrei Solntsev

selenide.org

Released Selenide 5.8.0

2020-02-28T00:00:00+00:00

Buenos noches!

We have merged next pack of pull requests and released Selenide 5.8.0.

What updates will you see there?

Simplified creation of custom conditions using lambdas

In class Condition there is a new method match which allows you to create custom conditions without need to subclass Condition. You just need to pass it a lambda.

See examples in tests:

$("#multirowTable").should(match("border=1", el -> el.getAttribute("border").equals("1")));

We also added similar methods for collections anyMatch, allMatch and noneMatch. See examples in tests:

$$("input").shouldBe(anyMatch("value==dog", el -> el.getAttribute("value").equals("dog")));
$$("input").shouldBe(allMatch("value==cat", el -> el.getAttribute("value").equals("cat")));
$$("input").shouldBe(noneMatch("value==bird", el -> el.getAttribute("value").equals("bird")));

See issue 662.
Thanks to Dmytro Stekanov for PR 1059.

Added methods `$.sibling()` and `$.preceding()`

… which allow you to find “previous” and “following” elements on the same DOM level. It can be useful when you don’t have good locators, but need to navigate in DOM tree.

See examples in tests:

$("#multirowTableFirstRow").sibling(0).shouldHave(id("multirowTableSecondRow"));
$(".second_row").parent().preceding(0).find("td", 0).shouldHave(cssClass("first_row"));

See issue 845.
Thanks to Dmytro Stekanov for PR 1064.

Added support for pseudo-elements

As many of you know, there are things in HTML called pseudo-elements: “:before”, “:after”, “:first-letter”, “:first-line”, “:selection”. They can contains important texts and styles that you sometimes want to check. Now it’s possible.

See examples in tests:

$("h1").shouldHave(pseudo(":first-letter", "color", "rgb(255, 0, 0)"));
$("abbr").shouldHave(pseudo(":before", "content", "\"beforeContent\""));
$("abbr").shouldHave(pseudo(":before", "\"beforeContent\""));

You can also ask for a value of pseudo-element from SelenideElement (but we do not welcome this method):

assertThat($("h1").pseudo(":first-letter", "color")).isEqualTo("rgb(255, 0, 0)");
assertThat($("abbr").pseudo(":before")).isEqualTo("\"beforeContent\"");

See issue 994.
Thanks to Denys Shynkarenko for PR 1045.

Fixed SoftAssertionsExtension for JUnit5

If one of your tests failed, SoftAssertionsExtension also marked all following tests as failed. Ups.

See issue 1071.
Thanks to Alexei Vinogradov for the fix.

Now `$.click()` always clicks in the CENTER of an element

Usually method $.click() did click in the center of the element. But if you set Configuration.clickViaJS=true, it clicked in the top left corner.
Not that it was critical, but you never know … Now it always clicks in the center. Just in case. Just to keep the same behaviour in all cases.

See commit 106c53941c718.

News

Wow! John C. Pratt created a Selenide Exporter for Katalon Recorder (works with Katalon Recorder).
We discovered phpSelenide - a Selenide port to PHP.
And if you didn’t know, SeleneJS - a Selenide port to JavaScript.

Andrei Solntsev

selenide.org

Released Selenide 5.7.0

2020-02-07T00:00:00+00:00

Buchahos!

Recently we got a lot of pull requests with lot of useful changes. This is the power of open source!

We have merged all those changes and released Selenide 5.7.0.

Added setting `Configuration.downloadsFolder`

Before now, Selenide downloaded files to folder build/reports - the same folder which contains generated test reports.
But sometimes people want to have reports and screenshots in separate folders.
For those people we added a dedicated setting Configuration.downloadsFolder - now Selenide will download files there.

By default it’s build/downloads.

See issue 1025.
Thanks to Dmytro Stekanov for PR 1041.

Download files to `Configuration.downloadsFolder` instead of `~/Downloads`

We had one more nuance when downloading files via proxy (Configuration.fileDownload=PROXY).
Selenide downloads files to its own folder build/reports (now build/downloads), but browser also downloads the same files to folder ~/Downloads (or what is the system default). It takes disk space, and nobody cleans up those files after test run.

Now Selenide configures webdriver to download files to folder build/downloads.

But only for Chrome and Firefox by now.
And only in case of Selenide opens webdriver by itself.

See issue 1057. Thanks to Dmitri Korobtsov for code review of PR 1058.

Added method for switching between windows with custom timeout

As you know, Selenide has methods for switching between tabs/windows:

switchTo().window(3);

This method is smart enough to wait until window is loaded. But it was impossible to set a timeout: the default 4 seconds was used here.

Now we added a overloaded method with timeout parameter:

switchTo().window(3,  Duration.ofSeconds(42));
switchTo().window(3,  Duration.ofMillis(16000));

See issue 399.
Thanks to Dmytro Stekanov for PR 1054.

Added logging of “readonly” attribute

See issue 990.
Thanks to Dmytro Stekanov for PR 1042.

Fixed IndexOutOfBoundsException

… when searching first/last element of an empty collection

See issue 991.
Thanks to Dmytro Stekanov for PR 1043.

And several screenshot improvements

1. Returned the lost screenshots in `Screenshots.getLastScreenshot()`

See issue 814 and issue 880.
Thanks to Petro Ovcharenko for PR 1052.

2. Fixed link to screenshots in Jenkins

Now Selenide can read environment variable BUILD_URL, and you don’t need to set system variable BUILD_URL in your build scripts.

Thanks to GongYi for PR 1049.

3. Fixed paths to screenshots in multi-module Maven builds

Thanks to GongYi for PR 1049.

Upgraded to WebDriverManager 3.8.1

See changelog (including support for Edge 80).

Events

SeleniumCamp 2020

Welcome to Kiev in February, 21-22 to SeleniumCamp conference!
I will present two talks:

and I will also hold an informal BOF session about Selenide roadmap.

Meetup about Selenide in Germany

Some folks organize a Selenide meetup in Germany in February, 12.
That’s cool, right?

Downloads statistics

The number of Selenide downloads over the year increased 2.5 times from 40 thousand to 110 thousand.

And the number of unique IPs exceeded 20 thousand:

We are growing!

Andrei Solntsev

selenide.org

Released Selenide 5.6.1

2020-01-14T00:00:00+00:00

Happy New Year for everyone!

New year - new release. Please welcome Selenide 5.6.1.

Added method `Selenide.executeAsyncScript()`

I guess all of you have used method Selenide.executeJavaScript(). JavaScript gives us a big power in test automation.

Now we added a method Selenide.executeAsyncScript(). It can be used for executing asynchronous functions (like setTimeout, $.get etc.)

Please note that it’s a little bit harder to use than executeJavaScript().
After calling asynchronous JS methods need to execute callback with a return value. You have to get callback from a last argument:

long value = (Long) Selenide.executeAsyncJavaScript(
      "var callback = arguments[arguments.length - 1]; " + 
      "setTimeout(function() { " + 
      "   // Here is your asynchronous JS code: " +
      "   ... " +
      "   // and return to Selenium: " +
      "   callback(10);" + 
      "}, 5000);"
    );
    assertThat(value).isEqualTo(10);

See issue 1030.
Thanks to Thierry Ygé for PR 1031.

Now Selenide can download files without `Content-Disposition` header (via proxy)

As you know, Selenide can download files via its built-in proxy server.
But until now, it intercepted only server responses containing Content-Disposition header (to get the name of file being downloaded).

But it appeared that this header is not always required. Sometimes files can be downloaded without this header.

Now Selenide proxy got to be smarter. Starting from Selenide 5.6.1, it works as follows:

Before starting download, it waits until all previous requests/responses between browser and server are completed.
It clicks the download button.
It intercepts ALL requests between browser and server (no matter which headers they contain).
And tries to understand which of them is more like a file download.

If this response doesn’t contain Content-Disposition header, the name of the file is taken from URL.

See issue 1034 and PR 1035.

Fix method `WebDriverRunner.using()`

We added method using in October, 2019.
We recently found a bug in this method: it closed the webdriver (but should not). Now we fixed this bug.

See commit 4d1b19972d.

Upgraded to WebDriverManager 3.8.0

It contains lot of bugfixes, including those reported by me :)

See changelog.
Among other improvements, WDM can now work without internet access.

News

Wow! Welcome Selenious - a port of Selenide to .NET platform.
Article from LambdaTest: Selenide Tests With LambdaTest – Online Selenium Grid For Automated Cross Browser Testing
My video from Cyprus Quality Conference Threesome: Selenide for Web, Android and iOS in October, 2019.
In case you missed it: series of posts Selenide Advent Calendar 2019

Andrei Solntsev

selenide.org

Released Selenide 5.6.0

2019-12-26T00:00:00+00:00

Good morning!

In the end of the year, we released Selenide 5.6.0 with one significant change.

We replaced (outdated) BrowserMobProxy by its fork BrowserUpProxy (current version 2.0.1).

See issue 1019.
Thanks to Aliaksandr Rasolka for PR 1020.

What good is there is `BrowserUpProxy`?

supports Brotli Compression (in addition to gzip)
supports HTTP/2
based on actively maintained fork LittleProxy
uses a better HAR reader
can filter HAR entries
supports versioned headers for JSON like Content-Type=application/something-v1+json
has built-in asserts for network and pages

Here is the full changelog of BrowserUpProxy (compared to BrowserMobProxy).

How to upgrade?

In most cases, you don’t need to change anything. Everything just work as before.
Some changes are required only in 2 cases:

1. If you declared BMP dependency explicitly, you need to replace

net.lightbody.bmp:browsermob-core:2.1.5

com.browserup:browserup-proxy-core:2.0.1

2. If you implemented `RequestFilter` or `ResponseFilter`,

you need to replace import

import net.lightbody.bmp.*;

import com.browserup.bup.*;

That’s it. Nothing more.

News

Google post about DAMP and DRY principles
One more framework on top of Selenide: JustTestLah! (JTL) - Hybrid of BDD, Selenide, Appium for Android, iOS and Web
In case if you missed it, posts series Selenide Advent Calendar

Andrei Solntsev

selenide.org

JavaScript tricks

2019-12-24T00:00:00+00:00

Good Christmas!

Today is December, 24. It’s Christmas. It’s the last day of our Selenide Advent Calendar.

In this last day, we will play JavaScript.

As a language, JavaScript is a disaster, but it gives a big power when used in automated tests.
It allows you doing things that are impossible with pure WebDriver.

Let me show few examples from real projects.

Pick a date

There is a lot of different “date pickers” out there. It’s always a headache to pick a date using them.

How to pick a date in your test?

@Test {
  setDateByName("recurrent.startDate", "16.01.2009");
}

A straightforward way could be like this:

Click a “calendar” icon
Click a year number
Click “previous month” arrow (how many times?)
Click a day
Ooops, today is February, 29. The test failed.

This way is slow and unstable.

And this is how it can be implemented using JavaScript:

void setDateByName(String name, String date) {
  executeJavaScript(
    String.format("$('[name=\"%s\"]').val('%s')", 
    name, date)
  );
}

It’s fast and stable.

You might be confused because it’s not the “real” way. We will discuss it in the end. Hold on.

Hide the calendar

Assuming that the calendar was opened, how to close it?

A straightforward solution would be to click the “cross” in the corner of calendar modal dialog. Again, it’s slow and unstable:

the “cross” is always located in different corners
location of the “cross” can change depending on design, browser size etc.
sometimes calendar popup is opened slowly - you need to add explicit wait for the “cross” to immediately close it.

The idiotic situation.

It can be done much easier with JavaScript:

executeJavaScript(
  "$('.datepicker').hide();"
);

It’s fast and stable.

Flip a flipper

Imagine a page with “flipper” for choosing a card. To select a card, user has to make a right finger movement in a right direction.
How to emulate it with Selenium? It’s possible. All those Drag’n’Drop, Actions. Press, hold, move, release. All this is slow and unstable.
It can easily be broken because of minor design changes, different browser size, focus lost etc.

And this a solution with JavaScript:

void selectAccount(String accountId) {
  executeJavaScript(
    String.format("$('[data-account-id=\"%s\"]').attr('data-card-account', 'true')", accountId)
  );
}

Yes, it’s not trivial. We had to dive into the flipper’s code and understand what JS code it calls on flipping.
And call similar JS code from test. Yes, you need to apply your head, but this solution is fast and stable.

Choose and option in bootstrap select

Many UI frameworks replace the standard <select> with custom home-made “nice”/”usable” elements, made from bunch of <div>s, <span>s, <li>s etc. with bunch of CSS classes and styles. It’s always a pain for automation.

One of such UI frameworks is Bootstrap. It also has its <select>. We tried hard, but failed to clicks all those <div>s and <span>s in the right order to select the right option.

At the end, we implement the method:

@Test {
  selectBootstrap($(By.name("operationCode")), "11100");
}

with JavaScript:

void selectBootstrap(WebElement select, String value) {
  executeJavaScript(
    "$(arguments[0]).val(arguments[1]).trigger('change')", 
     select, value);
}

Fast and stable.

By the way, with the help of execute method you can make it even nicer:

$(By.name("operationCode")).execute(selectBootstrap("11100"));

Slider

There is a slider on a page. User can drag the slider back and forth from 0 to 100.
How to do it in test?

@Test {
  setMaxYearlyFee(100);
}

Even classical Drag’n’Drop doesn’t work here because we just haven’t a target element.
Again, we can use Actions: press - hold - drag (by coordinates?) - release. Again, it’s slow and unstable.

But we can use JavaScript:

void setMaxYearlyFee(int value) {
  executeJavaScript(
    "$('#sld').data('slider').value[0] = arguments[0];" +
    "$('#sld').triggerHandler('slide');",
    value
  );
}

Again, we had to dive into the slider code. But it works. It’s fast and stable.

But it’s not real?

I know, many of you are frustrated because “it’s not real, it’s fake. Tests must emulate real user’s behaviour. Otherwise tests can miss some real problem.”

I understand.

But I will argue.

Fast and stable tests are much, much better than “realistic” (but slow and unstable) tests.

If 30% of your tests fail during every run,
If you spent few hours to analyze every failed build,
If you manually click through your “automated” scripts to check that functionality is not broken (and it was just a flaky test),
If you fill an excel with failed-but-manually-checked test,
If there is no trust for tests in your company,

then what the hell is the benefit of your tests?
Hard, only harm.

I prefer fast and stable tests.
I prefer tests that can easily emulate dependencies and check “complex” scenarios that are almost impossible to reproduce in a “realistic” way.
I prefer to live in peace with understanding that the goal of automated testing was never to automate everything.

You might still say:

Nevertheless, my soul is calmer when everything is “for real”.

Sorry, I have to upset you.

You “realistic” Selenium WebDriver tests will never be real. They work differently (compare to real users). WebDriver sends a http request for each your command, and even - surprise! - applies some logic on JavaScript to check visibility of elements etc.
In some sense, actions with JavaScript are even more “realistic” that with WebDriver. It’s closer to what browser actually does.
And even your manual testers clicking through you scenarios - are not real! They work differently (compare to real users).

Live now with it. :)

What’s next?

That’s it. It was the last post of Selenide Advent Calendar 2019. Uhhhh!

I will be honest: I wrote it to train my hands and get used to write a lot. I hope it will help me to update our site and write Selenide documentation. Maybe even book. :)

These are the plans for next year.

Happy New Year!

Andrei Solntsev

selenide.org

Defaŭlta lingvo

2019-12-22T00:00:00+00:00

Defaŭlta lingvo

The name of today’s topic is Esperanto and translates as “default language”.

You may have noticed that some web applications or sites change their language depending on either your browser language setting or on your location.

Problem

In case you have international developers in your team all writing and running some tests on different computer, you also may have noticed that the very same tests is failing or passing because the applications was displayed in different languages on different machines.

If the application decides about the language based on user location, it can be difficult to write stable tests running everywhere. But if it is just “preferred browser language of the user”, then your task is much easier.

Solution

So if you have a test which is supposed to run with language that differs from the default language of your browser, you have following options. Let’s imagine you are writing the tests for German Locale.

Change the default language of you operational system. Poor you. Now the most of the programs will be showing in German. Ordnung muss sein!
Take your browser and setup it to be German the preferable language. Save away the profile. Google and experiment a lot about loading custom browser profile before starting your tests. Don’t forget to remove German from the top of preferred languages or otherwise, you know already, Ordnung….
Just make use of Chrome preference “intl.accept_languages” and set it to “de” (for German).

Of course you can very easily do it in Selenide. Setup the system variable chromeoptions.prefs=intl.accept_languages=de

You can do it either in code:

System.setProperty("chromeoptions.prefs","intl.accept_languages=de");

or even better in configuration file of Maven or Gradle

Maven

maven pom.xml

  ...
  <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.xx.yy</version>
        <configuration>
          <systemPropertyVariables>
            ...
            <chromeoptions.prefs>intl.accept_languages=de</chromeoptions.prefs>
          </systemPropertyVariables>
        </configuration>
    </plugin>
    ...

Gradle

likewise for gradle in gradle.properties (you additionally need a line or two in build.gradle to get this parameter transferred in to the test task in gradle)

systemProp.chromeoptions.prefs=intl.accept_languages=de

Command-line

You can then override the setting running mvn test or gradle test defining another value in the command line -Dchromeoptions.prefs=intl.accept_languages=ru

Example

Just run this short test and see the effect of different language settings.

open("http://wikipedia.org");
$("[data-jsl10n=slogan]").shouldHave(exactText("Die freie Enzyklopädie"));

I wish you all Fröhliche Weihnachten and Guten Rutsch!

Alexei Vinogradov

Big “wait” theory

2019-12-20T00:00:00+00:00

Big “wait” theory

The topic of “wait” mechanism is well-known and sometimes can be controversial.
The fact is that modern websites are problematic to be tested by test automation frameworks and generate many situations where standard Selenium methods are ineffective. If you have read Selenide documentation, you already know that classic explicit waits like:

element = (new WebDriverWait(driver, <timeOutForElement>))
  .until(ExpectedConditions.presenceOfElementLocated(By.cssSelector(<cssSelector>)));

element = (new WebDriverWait(driver, <timeOutForElement>))
  .until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector(<cssSelector>)));

have been replaced by Selenide with (way shorter) variants:

element = $(<cssSelector>).should(exist);
element = $(<cssSelector>).shouldBe(visible);

As we know assertions in Selenide are new version of explicit wait, which is well-described for example in documentation.

Today we won’t be looking at assertions and wait mechanism from the technical point of view, but we will think about good ideas and examples of using particular assertions in different situations.

Modern problems require modern solutions

1. `Thread.sleep()`

This is the worst possible thing, that could happen to our tests in Selenium.

Some situations just required to use it, and there were no other solutions to move forward. Sometimes QAs try to use it to wait for some page to load, sometimes they try to wait for some element when other waits fail. Unfortunately, this way we can lose a lot of time. If we use it only in one test, it’s not that dangerous cause it will take probably around 4 seconds of our time. But if we use it in 150 tests, it will substantially increase the time of performance. There is no need to explain why it’s a bad thing. Although sleep() is still available in Selenide, smart assertions mentioned before make it useless in sense of waiting for anything on the page. Check next points.

2. How to wait for page to load?

The easiest way is to choose some element from the page that we want to load and use Selenide method:

$(cssSelector).shouldBe(visible);

Notice that Selenide will try to find the element first, and then it will wait for the element to be visible. If it has not found the element it means that the page hasn’t loaded.

Also, we can designate some element from the page that we are leaving and use method:

$(element).should(disappear);

This way we create double-check for moving from one page to another, even if it takes a lot of time and previously we needed Thread.sleep().

3. Changing state of an element

It happens that we want to validate the state of an element that changes depending on actions taken by user. For example, element contains text informing us if some file has been uploaded or not. It is possible that we will upload the file but it will take some time to change the state of element, because back-end has to process the task and give back the information.

Normally in our test we would like to upload file and check the state of an element to make sure that action succeeded. But how do we know when the element will change its state? The uploading and processing time can be different depending on the file’s size. This is the moment where a lot of people would use Thread.sleep() if standard Selenium methods failed(it really happens, sometimes Selenium checks the state of some element and thinks that it’s just wrong).

With Selenide, we have a very smart tool for this purpose:

element = $(cssSelector).shouldHave(exactText(<expectedText>));

This way Selenide will wait for the default timeout period for the element to change its state. We can check it with no additional lines of code and we can be sure that Selenide will really wait for it.

What’s next?

These are just very basic ideas and examples on how to “wait” with Selenide. There are many more ways of doing it, and the fact is that now we have a lot of powerful tools to write our tests with real and effective waits that don’t need to be fixed with additional “sleeps”. It’s up to you what assertions will be added to your tests. Just make it smart and don’t waste the time, it’s a valuable thing :)

Maciej Grymuza (figrym@gmail.com)

How to get network data with proxy

2019-12-18T00:00:00+00:00

Good night!

In two previous posts of our Selenide Advent Calendar, we tried to find a way to read requests/responses between browser and server.
They both were not ideal because they cannot read BODY of requests and responses.

Finally, we try a third way - using a Selenide built-in proxy server.

Before test

As you know, Selenide already has built-in proxy server. You only need to enable it:

Configuration.proxyEnabled = true;

Now you need to say the proxy to start tracking requests:

  BrowserMobProxy bmp = WebDriverRunner.getSelenideProxy().getProxy();
    
  // remember body of requests (body is not stored by default because it can be large)
  bmp.setHarCaptureTypes(CaptureType.getAllContentCaptureTypes());

  // remember both requests and responses
  bmp.enableHarCaptureTypes(CaptureType.REQUEST_CONTENT, CaptureType.RESPONSE_CONTENT);

  // start recording!
  bmp.newHar("pofig");

After test

Now you need to get a HAR and analyze its entries:

    List<HarEntry> requests = bmp.getHar().getLog().getEntries();

HAR (HTTP Archive) is like an “archive” with all network requests recorded during the test run.

Every entry in it is a network request.
It has everything needed inside: URL, request and response, their http status and body.
Everything that we dreamed about.

Pros:

It has all data you needed
It’s easy to analyze it programmatically
Works in all browsers

Cons:

There is only one possible problem. When you run tests and browsers on different machines, and the “tests” machine is not accessible from the “browsers” machine, it’s just technically impossible to use proxy server.
Though I never understood why people make things that complex.

People, just run tests and browsers on the same machine. Everything will get MUCH SIMPLER!
If you need to parallelize - just parallelize TESTS.
If you need a cluster (grid) - just run TESTS on different cluster nodes (and they will run their browsers locally).
There is no reasons to make it more complex.

What’s now?

Now we can read network data during tests run.
But I hope you don’t really use it often. Usually it should not be needed. Maybe in very rare cases.
Usually it should be enough to just read application logs to understand what requests were sent to server.

Keep it simple.

Andrei Solntsev

selenide.org

How to get network data with JavaScript

2019-12-17T00:00:00+00:00

Good night!

In the yesterday post we tried to get browser logs with “goog:loggingPrefs” capability.
Now we will try to get browser network data with JavaScript.

It’s simple. We just need to call this JavaScript in the end of test:

String js = 
   "var performance = window.performance || window.mozPerformance" +
                   " || window.msPerformance || window.webkitPerformance || {};" +
   " return performance.getEntries() || {};";
String netData = executeJavaScript(js).toString();
logger.info("Network traffic: {}", netData);

The result looks like this:

Network traffic: [
  {name=https://selenide.org/quick-start.html, connectEnd=0, connectStart=0, decodedBodySize=32582, domComplete=724, domContentLoadedEventEnd=119, domContentLoadedEventStart=115, domInteractive=104, domainLookupEnd=0, domainLookupStart=0, duration=724, encodedBodySize=32582, entryType=navigation, fetchStart=0, initiatorType=navigation, loadEventEnd=724, loadEventStart=724, nextHopProtocol=http/1.1, redirectCount=0, redirectEnd=0, redirectStart=0, requestStart=0, responseEnd=0, responseStart=0, secureConnectionStart=0, serverTiming=[], startTime=0, transferSize=0, type=navigate, unloadEventEnd=10, unloadEventStart=9, workerStart=0},
  {name=https://selenide.org/assets/themes/ingmar/css/styles.css?001, connectEnd=12, connectStart=12, decodedBodySize=8177, domainLookupEnd=12, domainLookupStart=12, duration=29, encodedBodySize=8177, entryType=resource, fetchStart=12, initiatorType=link, nextHopProtocol=http/1.1, redirectEnd=0, redirectStart=0, requestStart=12, responseEnd=41, responseStart=21, secureConnectionStart=0, serverTiming=[], startTime=12, transferSize=0, workerStart=0},
  {name=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js, connectEnd=13, connectStart=13, decodedBodySize=84245, domainLookupEnd=13, domainLookupStart=13, duration=28, encodedBodySize=84245, entryType=resource, fetchStart=13, initiatorType=script, nextHopProtocol=http/1.1, redirectEnd=0, redirectStart=0, requestStart=13, responseEnd=41, responseStart=21, secureConnectionStart=0, serverTiming=[], startTime=13, transferSize=0, workerStart=0}
]

Pros:

You don’t need to setup the browser. It works out of the box.
It works in all browsers (I guess?)

Cons:

We still don’t see request body here.
It’s not a valid JSON. We cannot parse it with a standard parser. Would need to create some custom parser.

But this option is quite ok to look at and understand what happens.

What’s next?

Our last hope to get request bodies is built-in proxy server. We will look at it next time.

Andrei Solntsev

selenide.org

How to get browser logs

2019-12-16T00:00:00+00:00

Good evening!

We continue our Selenide Advent Calendar.
Today we will try to look into browser “developer tools”.
It may be useful if you want to know what errors happened during test run, or what requests your AUT sent.

Chromedriver suggests the following receipt.

1. Add a couple of lines before opening a browser:

LoggingPreferences logPrefs = new LoggingPreferences();
logPrefs.enable(LogType.BROWSER, Level.ALL);
logPrefs.enable(LogType.PERFORMANCE, Level.ALL);
capabilities.setCapability("goog:loggingPrefs", logPrefs);

This capability was named “loggingPrefs” until some version of Chrome, and then was renamed to “goog:loggingPrefs”.
Not sure about other browsers.

Besides BROWSER and PERFORMANCE there are other types too, but I didn’t understand them.

2. Fetch the logs in the end of test:

Logs logs = getWebDriver().manage().logs();
printLog(logs.get(LogType.BROWSER));

void printLog(LogEntries entries) {
    logger.info("{} log entries found", entries.getAll().size());
    for (LogEntry entry : entries) {
      logger.info("{} {} {}",
        new Date(entry.getTimestamp()), entry.getLevel(), entry.getMessage()
      );
    }
  }

3. This is how BROWSER logs look like:

BROWSER logs:

Mon Dec 16 19:29:42 EET 2019 SEVERE http://localhost:9126/page/image/payment-promo-campaign-ozon.png - Failed to load resource: the server responded with a status of 404 (Not Found)
Mon Dec 16 19:49:14 EET 2019 INFO console-api 19:16 "start loading loans"
Mon Dec 16 19:49:14 EET 2019 INFO console-api 21:18 "loaded loans"

Here you can see all logs usually seen at “Developer Tools” -> “Console” tab. Including console.log messages and JavaScript errors.

4. And this is how PERFORMANCE logs look like:

PERFORMANCE logs:

{"message":{"method":"Network.loadingFinished","params":{"encodedDataLength":0,"requestId":"2C9E49BC49DCD3CA6EA9644255E34DE5","shouldReportCorbBlocking":false,"timestamp":141439.076528}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}
{"message":{"method":"Page.loadEventFired","params":{"timestamp":141439.234207}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}
{"message":{"method":"Page.frameStoppedLoading","params":{"frameId":"FF1A4E4EAAD7143749CD3740DF9BB95F"}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}
{"message":{"method":"Page.domContentEventFired","params":{"timestamp":141439.234834}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}
{"message":{"method":"Page.frameResized","params":{}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}
...
{"message":{"method":"Network.dataReceived","params":{"dataLength":0,"encodedDataLength":327,"requestId":"58583.71","timestamp":141474.021635}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}
{"message":{"method":"Network.loadingFinished","params":{"encodedDataLength":586,"requestId":"58583.71","shouldReportCorbBlocking":false,"timestamp":141473.994219}},"webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"}

Pros

Every record is a valid JSON. You can parse and analyze right in your test.

This is how the first record looks formatted:

{ 
   "message":{ 
      "method":"Network.loadingFinished",
      "params":{ 
         "encodedDataLength":0,
         "requestId":"2C9E49BC49DCD3CA6EA9644255E34DE5",
         "shouldReportCorbBlocking":false,
         "timestamp":141439.076528
      }
   },
   "webview":"FF1A4E4EAAD7143749CD3740DF9BB95F"
}

Cons

It’s hard to understand those logs. Some additional analyzers might be needed.
We don’t see request body here.

What’s next?

Next time we will try other ways to get browser logs - including http statuses and request bodies.

Andrei Solntsev

selenide.org

Drag and Drop

2019-12-15T00:00:00+00:00

Hi all!

Today is 15th day of our Selenide Advent Calendar.

Today we will watch a short funny video demonstrating how to drag-and-drop elements in Selenide.

Selenide can drag-and-drop web elements?

Yes, Selenide has method Drag’n’Drop. This is a boring description from Selenide blog:

  $("#from").dragAndDropTo("#to")

And this is a funny demonstration by Martin Škarbala:

That’s marvellous!

Andrei Solntsev

selenide.org

Actions

2019-12-12T00:00:00+00:00

Hi!

In today’s advent calendar article we will check how to perform special operations in Selenide.

Sometimes in our tests we encounter weird problems. It is 100% sure that all of us have experienced, or will experience some unusual problem that will make our work blocked. It happens quite often that for example we cannot click some element on the page, and standard selenium/selenide command like:

  element.click();

does not work. There can be many different reasons that will make our click operation ineffective but we cannot give up just like that, and we have to find some solution. In this case, in Selenium we had Actions class that helped us performing click operation in a bit different way:

  WebElement element = <Some selector>;
  Actions actions = new Actions(driver);
  actions.moveToElement(element);
  actions.click();
  actions.build().perform();

This way we were able to click the element and solve some of our problems occurring in tests.

But how can we do it in Selenide?

As it turns out, it is easier and simpler than it was in Selenium.
Selenide solves many problems that were quite common in Selenium, but if we need to perform some things in a bit different way, actions are still available in Selenide. Here we can check how it goes:

  SelenideElement element = $(<some selector>);
  actions().moveToElement(element).click(element).perform();

As we can see, actions is just a method available when we have:

  import static com.codeborne.selenide.Selenide.*;

imported to our project. Notice that no driver is needed to use actions() method!

Crazy drag and drop

If you have read the documentation, you probably already know that there are two types of drag and drop operations available in Selenide by default:

dragAndDropTo(java.lang.String targetCssSelector);
dragAndDropTo(org.openqa.selenium.WebElement target);

First method will let us drag and drop element to CSS selector defining target element.
Second method will just let us drag and drop some element to another one.

But what if we want to perform drag and drop action and we have no target element or css selector available?
For example, we have just an empty page and we want to put there some objects in many different places.
In this case, actions method will help us again. In Selenium we would have to code something like this:

  WebElement element = driver.findElement(By.some);
  Actions actions = new Actions(driver);
  actions.dragAndDropBy(element, xOffset, yOffset).perform();

Where xOffset is a horizontal move offset and yOffset is a vertical move offset.

In Selenide it should look like this:

	SelenideElement element = <Some selector>;
	actions().dragAndDropBy(element, xOffset, yOffset).perform();

This way we can drag and drop some object to the desired location without using additional target identifiers.

What’s next

Of course, these are just two examples of using special methods in Selenide and user can experiment with many more options.

Enjoy actions() !

Maciej Grymuza (figrym@gmail.com)

How to download a file with Selenide

2019-12-10T00:00:00+00:00

Good evening!
Today is December - and in this Selenide Advent calendar article we will take a look at the file download options in Selenide.

UPD
This article describes only 2 methods for downloading a file: HTTPGET and PROXY. Later we added the third method FOLDER and the fourth method CDP. Probably you need one of these methods - if your link doesn’t have href attribute, and you cannot enable proxy for some reason.

How can I download some file in my test?

At some point of our career all of us will face the problem of downloading the file in the test.

As we remember, in Selenium it wasn’t that easy, because different browsers required different configurations like creating new user profile in Firefox and setting preferences:

profile.setPreference("browser.download.dir", downloadPath);
profile.setPreference("browser.download.folderList", 2);
profile.setPreference("browser.download.manager.showWhenStarting", false);
profile.setPreference("browser.helperApps.alwaysAsk.force", false);
profile.setPreference("browser.helperApps.neverAsk.saveToDisk", mimeTypes);
profile.setPreference("browser.download.manager.focusWhenStarting",false);
profile.setPreference("browser.download.manager.useWindow", false);
profile.setPreference("browser.download.manager.showAlertOnComplete", false);
profile.setPreference("pdfjs.disabled", true);

In Selenide,

this problem has been solved by adding $.download() method.

When we want to download some file, we just have to perform:

File report = element.download();

and Selenide will handle with all downloads window popup and just close them when process is finished.

Selenide will create new folder containing our file in build/reports/tests. This is the folder where Gradle generate its rest reports, so that it’s convenient to have them all together.

We can edit our download directory by changing default settings:

Configuration.downloadsFolder = <desired location for downloaded files>;

BUT:

This way we will be able to download some file only when its element has “href” attribute.

What if my element does not have “href” attribute? For example, if file is generated as a result of form submission.

In this case, we have to organize downloading of our files in a bit different way. First of all we have to change settings:

Configuration.proxyEnabled = true;
Configuration.fileDownload = PROXY;

After changing these settings, we are able to download files from all kinds of elements, we don’t need a href attribute anymore - and we just have to use:

File report = element.download();

Tip:

Remember to set the appropriate timeout if you want to download files that have a big size - it will take more time to download them.

File will be downloaded to the default folder (something like C:\downloads and settings\downloads).
We have to remember that in case of some browsers, files are also downloaded to system downloads folder so our file will be present in two locations.

In the next steps we can for example delete folder with downloaded file using:

FileUtils.deleteDirectory(new File(<folder we want to delete>));  

For more detailed info about file downloading mechanism read this post.

Maciej Grymuza (figrym@gmail.com)

Why we banned statics and then allowed again?

2019-12-09T00:00:00+00:00

Good evening!

Here is the 9th day of Selenide Advent Calendar, and
I’ll tell you what excites the public most of all.

Why statics were banned in Selenide 5.0.0, but allowed again in 5.4.0?

Short answer: we banned them occasionally. But it was good.

Let me explain it in detail :)

How Selenide holds WebDrivers

Selenide stores webdriver instances in ThreadLocal.
It allows you to run tests in parallel: different threads get different webdrivers. The code looks like this:

class WebDriverRunner {
  private static final ThreadLocal<WebDriver> webdriver = new ThreadLocal<>();
  private static final ThreadLocal<SelenideProxyServer> proxy = new ThreadLocal<>();
}

Say, method $("a").click() works like this:

  WebDriverRunner.webdriver.get().findElement("a").click();

Briefly about SelenideDriver

But ThreadLocal implies one limitation: you cannot use two webdrivers in one thread
(as well as one webdriver in two threads - but aren’t there yet).

We planned to solve this problem in Selenide 5.0.0. We created a special class SelenideDriver, that allowed you to use two webdrivers in one test:

SelenideDriver browser1 = new SelenideDriver();
SelenideDriver browser2 = new SelenideDriver();

browser1.open("https://google.com");
browser2.open("http://yandex.ru");

browser1.$(h1).shouldHave(text("Google"));
browser2.$(h1).shouldHave(text("Yandeks"));

It forces us to do a major refactoring: we removed all usages of old good static method open(), $ and $$ inside Selenide itself. Every piece of Selenide code that needs a webdriver now gets a SelenideDriver parameter.
Yes, we had to pass this parameter everywhere…

Here comes the question

What should we do with old good static methods open(), $ and $$? They have to get SelenideDriver instance somewhere. Where to take it from?

Selenide 5.0.0: Statics got a punch

We added to class WebDriverRunner a third ThreadLocal:

  private static final ThreadLocal<SelenideDriver> selenideDriver = new ThreadLocal<>();

Briefly, SelenideDriver is a simple class with two fields WebDriver and SelenideProxyServer.
In general, it worked and solved the initial problem.

What I could not have envisioned at that moment was that so many folks defined their web elements in static fields:

public class MyPageObject {
  public static SelenideElement fname = $("#fname");
  public static SelenideElement lname = $("#lname");
}

And re-open the webdriver between tests.

One important detail:

We did one more improvement in Selenide 5.0.0.

Before 5.0.0, Selenide automatically opened a new browser if it wasn’t opened yet. At any moment.
Sometimes it caused perplexity because browser opened at unexpected moments (for example, when trying to log an error caused by a crashed browser).

Of course, it happened because of bad tests. Bug after all, we created Selenide to help people, right?

That’s why starting from version 5.0.0, Selenide didn’t occasionally open a browser anymore.
Instead, it said: “There is no an opened browser, I cannot do my job. You need to call method open() first.”

And what failed then?

The coincidence of these two factors led to the following problem:

Test creates a static field static SelenideElement fname = $("#fname").
This fname remembers a SelenideDriver it was created with.
Test closes the browser in the end.
A following test opens a new browser tries to use static field fname.
And fname calls its own instance of SelenideDriver it was created with.
And fails, because that `SelenideDriver has been closed.

More than a year - from September, 2018 to October, 2019 - I was trying to explain that static variables are evil.
I even created a special talk “Antistatic” (yes, this time in English:)).

But finally I gave up. Because it would be too big refactoring for many folks to rewrite their projects from static variables.

After all, we created Selenide to help people, right?

Selenide 5.4.0: Statics won

How we finally solved this problem?

The solution is quite simple. We replaced ThreadLocal<SelenideDriver> by a static variable (yep :))

private static final SelenideDriver = new ThreadLocalSelenideDriver();

Now this “static” SelenideDriver is a singleton. It always exists. It’s never closed. All static SelenideElement variables created with it will live forever. But it also doesn’t hold fields WebDriver and SelenideProxyServer. It fetches them from WebDriverRunner’s ThreadLocals every time.

P.S.

That’s why method WebDriverRunner.getSelenideDriver() disappeared in Selenide 5.4.0.

I was surprised that many people have already managed to use it. People, I do not understand you! How do you manage to use everything so wrong?
Well, it was my mistake to make this method public. But I never mentioned it in any of my posts nor documentation. I never recommended to use. How could someone decide to use it? How this magic happens?

What’s now

We returned the possibility to declare your SelenideElements in static fields.

But please do not abuse it.

I still don’t like it :)

Andrei Solntsev

selenide.org

How to test CSRF protection

2019-12-07T00:00:00+00:00

Hi all!

Today is 7th day of our Selenide Advent Calendar.
Today we will talk about testing security.

What is CSRF?

CSRF is one of the most popular security attacks (Cross-Site Request Forgery).

To protect itself from CSRF attack, a web-application should add a special parameter to (almost) every POST request. Typically it’s called authenticityToken (though the name may vary).

A typical mistake is when web-application either doesn’t send authenticityToken to server with some POST request or doesn’t check it on server side.

How to check the protection?

I assume you have some automated tests covering the most critical functionality of your web application.
We will kill two birds with one stone: during run of your tests, we will intercept every POST request and send exactly the same request, but with modified authenticityToken. And verify that the server returned an error. Usually it should be “403 Forbidden”.

Sounds hard. How to program it?

Now so hard.
As you know, Selenide can run its own embedded proxy server. Initially it was created for downloading files, but it also allows to add your own listeners which can intercept all requests between browser and server. We are going to use it.

Step 1. Enable Selenide proxy

Configuration.proxyEnabled = true;

(you need to do it BEFORE opening a browser)

Step 2. Add listener for the proxy

abstract class BaseTest {
  private AuthenticityTokenChecker authenticityTokenChecker = new AuthenticityTokenChecker();

  // somewhere after open("http://..."):
  getSelenideProxy().getProxy().addRequestFilter(authenticityTokenChecker);
}

Currently you can only add listeners AFTER opening a browser, which is sometimes inconvenient. I hope we will implement adding listeners at any moment in next Selenide release.

Step 3. Implement AuthenticityTokenChecker

import com.codeborne.selenide.Configuration;
import io.netty.handler.codec.http.*;
import net.lightbody.bmp.filters.*;
import net.lightbody.bmp.util.*;

public class AuthenticityTokenChecker implements RequestFilter {
  private final HttpClient httpClient = HttpClient.newBuilder().build();

  private final List<String> unprotectedUrls = new ArrayList<>(1);

  public void reset() {
    unprotectedUrls.clear();
  }

  public List<String> getUnprotectedUrls() {
    return unprotectedUrls;
  }

  @Override
  public HttpResponse filterRequest(HttpRequest httpRequest, HttpMessageContents contents, HttpMessageInfo httpMessageInfo) {
    if (httpRequest.getMethod() != HttpMethod.POST) return null;                   // ignore non-POST requests
    if (!httpRequest.getUri().startsWith(Configuration.baseUrl)) return null;      // ignore chrome requests to google.com etc.
    if (this url can work without authenticityToken) return null;                  // some post requests don't need csrf protection

    String body = contents.getTextContents();
    if (!body.contains("authenticityToken=")) {
      unprotectedUrls.add("No 'authenticityToken=' found for " + httpRequest.getUri() + " in " + body);
      return null;
    }

    sendHackedPostRequest(httpRequest, contents);
    return null;
  }
}

Note that return null; means “do not modify the request”, which means that the browser will still send the original request, and the normal flow of your test will not be affected.

Step 4. Send hacked POST request

  private void sendHackedPostRequest(HttpRequest httpRequest, HttpMessageContents contents) throws IOException, InterruptedException {
    // You need to tune this line. 
    // The request format (including name of parameter "authenticityToken") may depend on your application.
    // Note that the request can contain several "authenticityToken" parameters (immediately throw an error if they are different).
    // If the request contains a submitted form, especially with uploaded files, you need to modify "authenticityToken" a little bit differently. 
    String hackedBody = contents.getTextContents()
        .replace("authenticityToken=1234567890").to("authenticityToken=hack-me-if-you-can");

    java.net.http.HttpRequest.Builder builder = java.net.http.HttpRequest.newBuilder()
      .uri(URI.create(httpRequest.getUri()))
      .timeout(Duration.ofSeconds(1));

    for (Map.Entry<String, String> header : httpRequest.headers()) {
      if (!restrictedHeaders.contains(header.getKey().toLowerCase())) {
        builder.header(header.getKey(), header.getValue());
      }
    }

    java.net.http.HttpRequest request = builder
      .POST(java.net.http.HttpRequest.BodyPublishers.ofString(hackedBody))
      .build();

    log.info("Sending hacked request to {}", httpRequest.getUri());

    java.net.http.HttpResponse<String> httpResponse = httpClient.send(request, java.net.http.HttpResponse.BodyHandlers.ofString());

    if (httpResponse.statusCode() == 403) {
      log.info("Hacked request was rejected: {} {}", httpResponse.statusCode(), httpRequest.getUri());
    }
    else {
      log.error("HACK SUCCEEDED {} {}", httpResponse.statusCode(), httpRequest.getUri());
      unprotectedUrls.add("Detected URL without authenticity token check: " + httpRequest.getUri());
    }
  }

  private static final Set<String> restrictedHeaders = Set.of("connection", "content-length",
    "date", "expect", "from", "host", "upgrade", "via", "warning");

This implementation uses Java 11 built-in HttpClient. If you are that poor guy that still uses Java 8, you can easily replace it with OkHttp, Apache Http Client or some similar http client.

Step 5. Fail the test if some hacked request hasn’t got “Forbidden” error

abstract class BaseTest {
  @Before void resetChecker() {
    authenticityTokenChecker.reset();
  }

  @After
  public void verifyThatAllPostRequestsAreProtectedWithAuthenticityToken() {
    if (!authenticityTokenChecker.getUnprotectedUrls().isEmpty()) {
      fail(String.valueOf(authenticityTokenChecker.getUnprotectedUrls()));
    }
  }
}

What’s now?

We managed to automatically check if our application is protected against CSRF attacks.
(It’s not theoretical: we actually did it in one project and found two vulnerabilities in a real internet-bank.)

It’s good, but it’s not enough. There is a lot of other security attacks.

Keep track of OWASP 10, think creatively, and try to figure out how you could emulate other attacks with your automated tests.

Andrei Solntsev

selenide.org

How to visualize click

2019-12-06T00:00:00+00:00

Good evening!

Today is December 6th, you are reading the Selenide Advent calendar, and in today’s post I will show one simple technique how to catch some flaky tests.

What’s wring with clicks?

It’s an eternal problem: flaky tests. One of typical reasons of flaky tests: click doesn’t work.

As i described in this video on DelEx 2019 conference (sorry, the video is in Russian), click in selenium often doesn’t work if the element was moving or resizing at that moment. Or if it was covered by other element that suddenly appeared and got the click.

Why Selenide hasn’t solved it already?

A global solution could be like this: method $.click() waits for completion of any animations and movements before actually performing the click. Currently Selenide doesn’t have such a solution. I guess it’s impossible to make such waiting universal. All projects are different, with different frameworks and designs. If you have an idea how to implement such a waiting - feel free to drop me a notice.

But what we can is to highlight the element that actually got the click. It will not solve the problem entirely, but at least it helps to localize the problem.

How to highlight the element?

You can add the following JS code to your application.
It listens for all click events on the page and adds highlights with a green border the element that actually got the click.
It will help you to detect cases where a wrong element got the click.

#{if test}
    <script>
      function onClick(event) {
        var e = event || window.event;
        var target = e.target || e.srcElement;
        target.style['box-sizing'] = 'border-box';
        target.style['border'] = '2px solid green';
      }
    
      document.addEventListener('click', onClick);
    </script>
#{/if}

You might need to adjust this code to your needs: it depends on your application, framework, design etc.

Here you can see one example of possible solutions: Highlighter.

What’s now?

If you have flaky test (as all of us), you can start from this step.
At least you will see which element got the click.

Andrei Solntsev

selenide.org

How to check size effectively?

2019-12-04T00:00:00+00:00

Hello!

Today is December 4th, it’s the Selenide Advent calendar, and in today’s post I will show how to check a collection size effectively.

How to effectively check a collection size?

Selenide has convenient methods for checking collections. For example, this is how you can check that a book list contains exactly 3 books:

@Test {
 $$("#books .book").shouldHave(size(3));
}

If this page implemented so that it contains much more books, and only some of them are visible, then you can filter the collection:

@Test {
 $$("#books .book").filter(visible).shouldHave(size(3));
}

The problem

If the page contains a lot of books (say, a few dozens or more), this filtration can be slow (say, few seconds and more).
It’s because method filter(visible) needs to call WebElement.isDisplayed() separately for each element in the collection in loop. Every call means a separate call to webdriver, which is a separate http request etc. This all takes times.

Probably tests run 3 days in your project, and few seconds don’t really play any role. Then you can skip this post. :)

But if you care about effectiveness of your tests, go on.

The first try

How to speed up this check? The first idea is to filter elements right in the selector:

@Test {
 $$("#books .book:visible").shouldHave(size(3));
}

But this selector doesn’t work.

The problem is that there is no CSS selector :visible. It doesn’t exist. Only JQuery can understand it.

The second try

Who saves us? Of course, JavaScript!

You can create a helper method which finds a number of elements (with a help of JavaScript and JQuery):

private int sizeOf(String cssSelector) {
  Number count = executeJavaScript("return $(arguments[0]).length", cssSelector);
  return count.intValue();
}

(this code only works if the page contains JQuery library. If not, you can write a similar code using some other JavaScript library.)

Now your check will be fast because it calls WebDriver method only once. And browser executes any JavaScript very quickly.

@Test {
  assertEquals(1, sizeOf("#books .book:visible"));
}

What’s now?

Learn the power of JavaScript.
It allows many other tricks which can make your tests more fast and stable.

Andrei Solntsev

selenide.org

setWebDriver or WebDriverProvider?

2019-12-03T00:00:00+00:00

Good evening!

Today is December 3rd, you are reading the Selenide Advent calendar, and in today’s post I will answer one simple question.

Which one should I choose, `setWebDriver()` or `WebDriverProvider`?

As you know, Selenide opens a browser automatically and closes it at the right moment. You don’t need to care about the browser.

But sometimes you want to open a “custom” browser with some specific settings. Selenide has 2 methods for this. It happened so that I never wrote anywhere how to choose one of them.

So,

Option 1:

  Configuration.browser = MyWebdriverProvider.class.getName();

This option is preferred in most cases. It’s good because class MyWebdriverProvider is only responsible for HOW to open a browser (which options to pass, where to find binaries etc). But is not responsible for WHEN to open and close the browser. Selenide takes care of it.

Option 2:

@Before
public void setUp() {
  var yandexBrowser = new YandexDriver(...);
  WebDriverRunner.setWebDriver(yandexBrowser);
}

This option is worse because you are responsible not only for opening, but also for close the browser. This often causes misunderstanding. Selenide cannot close the browser because you might use it somewhere else. You open it - you close it.

This begs the question:

Why it’s needed at all?

Initially method setWebDriver() was created to enable easy adoption of Selenide in existing projects (without re-writing the existing codebase).

Imagine that company X already has a lot of automated tests on Selenium (or HtmlElements, Thucydides, Serenity or anything else). They want to write new tests on Selenide, but leave existing tests untouched.

Apparently they already have a code snippet in their codebase which opens and closes the browser. They want to say Selenide to use the same browser. That’s when method setWebDriver() is useful. It allows you to run the old and the new code all together, so that it works in the same browser.

As you see, the use of method setWebDriver() is rather narrow. I’m not sure at all if it was ever used in that vein. :)

What’s now?

If you are writing a new project, use WebDriverProvider. SRP.

UPD

Later in Selenide 5.16.1 we added one more option DriverFactory. Now it’s the recommended way to create a customized webdriver.

The idea is very similar to WebDriverProvider, but gives you more control over webdriver options. You need to

either implement interface DriverFactory,
or create a subclass of ChromeDriverFactory, FirefoxDriverFactory or similar class (which exist in Selenide and implement interface DriverFactory) and override only needed methods. All methods in these classes are made small and declared protected.

You can find examples in Selenide own tests.

How to abuse Selenide

2019-12-02T00:00:00+00:00

Good year!

It’s December, 02, and we continue with our Selenide Advent Calendar. This time will talk about invalid use of Selenide.

How to abuse Selenide

I often hear people complaining that the following code doesn’t catch the exception:

try {
  $(".banner").shouldBe(visible);
  $(".banner .close").click();
}
catch (Exception e) {
  // System.out.println("The element is not found - a banner hasn't appeared this time.");
}

The intention of this test is to check if a banner appeared. Not immediately, but wait for the banner a little bit: probably it will appear after some time. If the banner has appeared, the test needs to close it.

Why this is a bad test?

Because it’s slow.

In most cases, banner will not appear, and the test will waste 4 seconds (or what is your timeout).

It’s awful. Are you a professional engineer? Your goal is to make your tests fast and stable.

Why this test is very bad?

Because it’s unstable.

Sometimes banner will appear in the end of 4th second. Test decides that banner hasn’t appeared and goes on. At this moment the banner appears. Ups, you get a flaky test.

Why this test is very-very bad?

Because it doesn’t test the banner.

Imagine that banner hasn’t appeared during tests run. All tests are green. But in production, the banner appears for end-users. And when the banner appears, an error happens. The application crashes. Users complain.

But your tests are green.
Imagine the opposite. During your tests run, banner appears all the time. Well, that’s what happened in the test environment. But real users see the banner very rarely, and the error happens when they don’t see the banner. The application crashes. Users complain.

But your tests are green.

What can you do?

Obviously, you should have at least 2 tests:

Case when the banner appears, and
Case when the banner doesn’t appear.

To achieve that, you need a possibility to rule the banner. You should be able to show or hide the banner either using some API or admin console or by running SQL in database. Whatever. Every mean is good. If you don’t have such API, you should make a deal with developers and create it.

Don’t tell me that you can’t. Are you a professional engineer or what?

If you cannot, just delete this test. Cannot means CAN NOT.

And finally, the initial question:

Why that code doesn’t catch the Exception?

You probably guessed it, right?

The trick is with hierarchy of Java exceptions. The parent class of all java exceptions is Throwable, not Exception. Here is the hierarchy:

Throwable
- Exception
  - RuntimeException
    - WebDriverException
- Error
  - AssertionError
    - UIAssertionError
      - ElementShould

This is the reason why you miss all Error subclasses (including Selenide errors) when you catch (Exception e).

You might think: “Great, I will catch (Error e)”. No. NO! Please, NO!

Read the java.lang.Error javadoc:

An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions.

What’s now?

I hope you will stop catching exceptions in tests. The goal of tests is to report errors, not catch them.

I hope you will take the test environment under your control.

You need to decide, either you rule the banner, or the banner rules you.

Either you automate tests, or tests automate you.

Andrei Solntsev

selenide.org

The Main Algorithm

2019-12-01T00:00:00+00:00

Good December!

The Advent has begun.

Children are unpacking their advent calendars, opening one small window with a chocolate every day. In Java world, we have a Java Advent Calendar, in which many authors write a new article every day. I also participated in it could of times (2017 and 2018).

I also decided to start Selenide Advent Calendar. Every new day a new post. From 1st to 25th December. I am starting, and you can continue - just give me a notice by any possible way.

Today topic is:

The Main Algorithm

The main feature of Selenide, as many of you say, is automated waiting.
You don’t need to copy-paste boilerplate code like new WebDriverWait(driver, 30).until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//div[contains(text(),'COMPOSE')]"))) to wait for some event. You don’t need to waste your time and effort to decide where a waiting is needed. You don’t need to see a flaky tests and investigate where you should add one more new WebDriverWait.

With Selenide, everything is much more simple. Any line like $(byText("COMPOSE")).shouldBe(visible) waits automatically if needed.

Doesn’t it slower my tests?

No.

If the element is already visible, Selenide will just go on. If not - Selenide will wait for 100 ms and check again. If still not, wait for another 100 ms and check again. So it will continue up to 4 seconds. And only if the element will not appear after 4 seconds, then Selenide will fail the test.

Of course, those numbers 4s and 100ms are configurable.

How it works?

We are getting to the Main Algorithm. Actually, it’s very simple.

For example, this is how $(".btn").shouldBe(visible) works:

void shouldBeVisible() {
  do {
    try {
      assert webdriver.findElement().isDisplayed() == true;
      return ok;
    }
    catch (Exception e) {
      sleep(100 ms)
    }
  } while (less than N seconds);
  throw new ElementShouldBeVisible("Expected: foo, actually: bar");  // and take a screenshot
}

You see: the idea is really simple.

In reality, this code is a bit more complex. It’s because it’s “generic” - not only for shouldBe(visible), but for all other methods and conditions.

As you know,

the devil is in the details

In the code shown above, there is plenty of questions:

Which exceptions to catch?
- Exception, Error, Throwable, AssertionError, WebDriverException?
In case of which exceptions should we stop the waiting and fail the test immediately?
- for example, if XPath is invalid, it will remain invalid after 4 seconds too.
The result is ok or nok?
- for example, if element is not found - it could be ok for condition $.shouldNot(exist).
At what moment would we take screenshot?
Can user customize any of these lines?
- For example, it’s probably not needed to take a screenshot because Allure will take its own screenshot anyway.
- Or the opposite, we probably should take screenshot and pass it to Allure somehow?
- (currently both Selenide and Allure take a screenshot, so they are duplicated)
What if we run until the last line, and during execution of the last line we got a fu#ng StaleElementException?

Our answers to these questions have been changing in time. And will probably change. But the essence remains.

What’s now?

I hope you will now understand Selenide waiting instead of perceiving it as a “black magic”. It will probably help you during debugging of some corner cases and mystical test failures.

And you can even suggest an idea how to improve or simplify the ~~Skynet core~~ Main Algorithm.

Andrei Solntsev

selenide.org

Released Selenide 5.5.1

2019-11-29T00:00:00+00:00

Hi all!

At Black Friday, we released Selenide 5.5.1 with a couple of new features.

Mobile browser emulation
Deprecated method Selenide.close()
News

We added mobile browser emulation

Sometimes you want to run browser not on a usual Chrome, but on Chrome “like in mobile”.

Like you would open a browser in mobile phone or tablet.

(For example, site selenide.org looks ugly on mobile. :( We are working on it.)

Now it’s easy to do it by adding a System property before running tests:

java -Dchromeoptions.mobileEmulation="deviceName=Nexus 5"

or right in your code:

System.setProperty("chromeoptions.mobileEmulation", "deviceName=Nexus 5");

NB! We are talking only about one setting - a device name. It should be enough in most cases. If you need to tune other mobile browser settings, please implement WebDriverProvider interface.

See issue 1008 and PR 1011.

We deprecated method `Selenide.close()`

Selenide always had method Selenide.close(). But its name is misleading: it closes the whole browser, not only a current window. The problem is that Selenium Webdriver also has method close() which only closes a current window/tab (and the whole browser only if it was the only window/tab). And for closing the whole browser Selenium has method quit().

It was my fault that I created method close() without reading Selenium documentation. I was young and didn’t believe in Javadoc. :) But part of the problem is that Selenium names close vs quit are not intuitive. Go figure which of them closes what.

To make your life easier, we now suggest two method with explicit names:

Selenide.closeWindow() - closes a current window (or tab, which is the same)
Selenide.closeWebDriver() - closes the whole browser

Now you don’t need to remember anything.

The old method Selenide.close() is now deprecated. Going to delete it in Selenide 6.0.0

See issue 1016 and PR 1017.

News

Wow! A new IDEA plugin for Selenide/Selenium: QA Lithium. Thanks to Yuriy Artamonov!
Another framework on top of Selenide: Masquerade - CUBA Platform UI Testing Library
Article about Selenide and Selenoid
Another article about Selenide and Selenoid

Andrei Solntsev

selenide.org

Released Selenide 5.5.0

2019-10-31T00:00:00+00:00

Good evening!

How do you celebrate Halloween?

We released Selenide 5.5.0 with some backward incompatible changes.

ARE YOU SCARED?

Migrated from JUL to SLF4J

Sometimes Selenide needs to write down some diagnostic logs, like “I found browser binary in foo”, “I failed to save screenshot to bar” etc.

Until now, Selenide did write its logs using Java built-in mechanism java.util.logging (aka JUL). It has some known disadvantages, that’s why there is plenty of alternatives in the Java world: Log4J, Slf4j, Logback, JCL.

How it works:

Slf4J is a “facade”, something like “interface”. Selenide will write logs using it.
And Log4j, Logback, JCL are implementations of this “interface” (probably there are more of them).

You decide which implementation of Slf4J you want to use. Most probably this decision is already done in your project, because at least WebDriverManager always wrote logs using Slf4J.

To use one of Slf4J implementations, you need to add corresponding dependency to your project:

slf4j-log4j12-*.jar
logback-classic-*.jar
slf4j-simple-*.jar
slf4j-jdk14-*.jar
slf4j-jcl-*.jar
slf4j-nop-*.jar (NO! Please DON’T! It just ignores all logs.)

NB! Let me remind: most probably you already have one of these dependencies. So you don’t need to do anything.

If you still don’t have any of these dependencies, you will see such message when running tests (I will not see Selenide logs):

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

If you see it, probably the easiest solution would be to add one line to your build.gradle:

testRuntimeOnly 'org.slf4j:slf4j-simple:1.7.28'

or in pom.xml:

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.28</version>
    <scope>test</scope>
</dependency>

NB! If you failed to setup Slf4j - don’t panic. Selenide logs are not so much important. Test failures will not disappear. We are only talking about diagnostic INFO and WARNING logs like INFO Using browser binary: /var/lib/opera.exe.

See 923.

Thanks to Gleb Schukin for PR 926.

Removed HtmlUnit and PhantomJS dependencies

Don’t be afraid, your tests should still work with HtmlUnit and PhantomJS. Just Selenide will not bring these dependencies transitively (because most of people already migrated to headless chrome and headless firefox).

If you still want to use HtmlUnit or PhantomJS, you just need to add corresponding dependencies to your project.

Thanks to Aliaksandr Rasolka for PR 1003 and PR 998.

Removed built-in support for Safari browser

But don’t worry, you can still use Safari! See the instruction

Made method `$.execute(command)` generic

Before now, method$.execute accepted only Command<SelenideElement>, but now it can accept any Commands.

See issue 1000 and PR 1001.

Fixed setting `holdBrowserOpen`

.. which we broke in Selenide 5.4.1. Now browser is left opened again, and you can investigate your failed tests.

See issue 999 and PR 1005.

Take a screenshot in case of `DialogTextMismatch` error

As you know, Selenide has a method for verifying text of modal dialog (alert or confirm):

confirm("Are you sure?");

But when this check failed, Selenide forgot to take a screenshot. Now it’s fixed.

See issue 907. Thanks to Nick Holloway for PR 986.

Refactoring of `ScreenShotLaboratory`

Though it’s just a refactoring, and it will not affect you, I must mention the initiative of SeleniumTestAB who decided to improve Selenide code and sent PR 1004 and PR 1006.

Good job!

News

Presentation about Selenide on EclipseCon 2019: A complete Selenium Techstack
My presentation for Cyprus Quality Conference Threesome: Selenide for Web, Android and iOS”. So far, only slides.

And the most important!

Selenide got 8 years old!

25.10.2011 a first commit to Selenide was done.

After 8 years, we have:

89K downloads from 14K unique IPs (per month)
1K stars on github
55 contributors

Many thanks to all contributors, users, critics, ideologists and just sympathizers.

This is just the beginning :)

Selenide download statistics for October, 2019:

Andrei Solntsev

selenide.org

Released Selenide 5.4.1

2019-10-16T00:00:00+00:00

Good evening!

There is nothing in the World more boring than October. Let’s brighten it up with bright news!

Today we released Selenide 5.4.0 with a couple of noticeable changes which many of you have been asking for a while.

UPD There was a bug in 5.4.0, so please upgrade to 5.4.1

UPD 2 There is also a minor bug in 5.4.1: Configuration.holdBrowserOpen doesn’t work. Will fix it in next version. I hope you don’t use it often.

1. Fixed “IllegalStateException WebDriver has been closed”

Starting from Selenide 5.0.0 (~1 year ago), many users started complaining about
IIlegalStateException WebDriver has been closed....

Actually it’s not a bug, it was intended behaviour. I didn’t want to fix it for a while because I believe such an exception cannot happen in well-designed tests. Selenide threw in intentionally to stimulate people design their tests better.

But we had too many complaints, so I decided to remove this exception - with a heavy heart!

In the end, everyone has the right to fill their own bumps.

How this error happened?

Shortly speaking, this exception happens when instance of SelenideElement is reused with multiple instances of SelenideDriver. It can happen when SelenideElement is declared as a static field (either of a page object or a test). And is initialized before the browser is opened. Or browser is restarted between tests. It also may happen when people use Cucumber which tries to initialize step objects, page objects before opening a browser. Some folks also put Guice or Spring to their test.

All of this is over-engineering. It’s just not needed.

People, you don’t need all these things in tests. Tests must be simple. KISS, amen!

Watch this presentation to know why Static fields are evil.

What’s changed?

But well, people can have different opinions. As a sign of tolerance, let’s meet Selenide 5.4.0

Now this code will work without exceptions:

public class SomeClass {
  private static SelenideElement body = $("body");

  public static void main(String[] args) {
    open("https://mail.ru");
    body.should(exist);

    Selenide.close();

    open("https://mail.ru");
    body.should(exist);   // it threw "IllegalStateException WebDriver has been closed" before Selenide 5.4.0
  }
}

You can find more examples and complaints in issues 862, 902, 954, 922, 873.

If you are interested in implementation details, welcome to PR 989.

2. Now method `SelenideDriver.close()` always closes the browser

Starting from Selenide 5.0.0, people started complaining that method close() doesn’t close the browser. It happened in (rare) cases when browser was opened by user code, not Selenide.

SelenideDriver browser=new SelenideDriver(new FirefoxDriver());
browser.close(); // it didn't close the browser
browser.getWebDriver().close(); // it did close the browser

Actually it’s not a bug, it was intended behaviour. Selenide initially has this principle: it closed only the browser opened by Selenide itself. And never closed the browser opened by user: it might be used somewhere else.

But again, we had a lot of complaints. It caused a hassle: you see method close(), you call it, it works without exceptions - but the browser is still open.

Now we fixed it. Method close() always closes the browser.

P.S. If your browser is now being unexpectedly closed - feel free to fire a github issue, we will investigate it.

See issue 896 and PR 989

3. We restored short human-readable error messages

You might notice that Selenide 5.3.1 introduced one minor issue. Error messages became longer and hard to read:

com.codeborne.selenide.ex.ElementNotFound: Element not found {#customerDashboardButton}

Now we returned the old good human-readable messages:

Element not found {#customerDashboardButton}

P.S. Poor users of maven-surefire-plugin 2.22.2 will still have long messages, see details here.

See PR 993

4. Added method `using` for easier switching between multiple webdrivers

As I already said before, using of multiple webdrivers in one test is a bad practice in absolutely most cases.

But again, everyone has the right to fill their own bumps. Now it’s a little more easier to fill that bumps with multiple webdrivers.

Before Selenide 5.4.0, you had to call setWebDriver() all the time - and keep in mind which browser is active at the moment:

var browser1 = new FirefoxDriver();
var browser2 = new FirefoxDriver();

setWebDriver(browser1);
open("http://google.com");
$("h1").shouldHave(text("Released Selenide 5.4.0"));

setWebDriver(browser2);
open("http://yandex.ru");
$("h1").shouldHave(text("Released Selenide 5.4.0"));

now you can wrap code blocks for different browsers in separate using calls:

var browser1 = new FirefoxDriver();
var browser2 = new FirefoxDriver();

using(browser1, () -> {
  open("http://google.com");
  $("h1").shouldHave(text("Released Selenide 5.4.0"));
});

using(browser2, () -> {
  open("http://yandex.ru");
  $("h1").shouldHave(text("Released Selenide 5.4.0"));
});

See PR 976 and code samples in CustomWebdriverTest.java.

5. Added protection against one typical error with xpath

Here is the typical error:

$(".parent").find(By.xpath("/child")).shouldBe(visible);

The problem is that XPath starting with a slash (“/”) looks for element from the root of the document (not from .parent element).

We added a protection. Now this code will throw an exception which clearly states the problem and saves your time:

IllegalArgumentException: XPath starting from / searches from root

The code above can be fixed in different ways (depending on what you actually need):

$(".parent").find(By.xpath("./child")).shouldBe(visible);
$(".parent").find(By.xpath(".//child")).shouldBe(visible);
$(".parent").find(By.xpath("child")).shouldBe(visible);

See PR 963 and PR 975.

6. Upgraded dependencies

upgrade to webdrivermanager:3.7.1
exclude old Guava dependency coming from net.lightbody.bmp:browsermob-core:2.1.5

Just in case, we discovered a bug in WDM: when you want to download chromedriver 77, it may download “75.0.3770.90” instead. It’s because this version contains substring “77”. Isn’t it funny? :)

News

A new utility Jabel from Sergei Egorov:
now you can write code in Java13 but compile to Java8. Unbelievable, but it’s possible!
Video about Selenide in German
English-speaking world discovers Selenide. The post also contains a link to a podcast about Selenide.
Martin Škarbala from Slovakia added english subtitles to his great video about Selenide:
Selenide - stručné UI testy.
The World Needs Full-Stack Craftsmen - Anton Keks, GeekOut, Tallinn, 26.09.2019

Andrei Solntsev

selenide.org

Released Selenide 5.3.1

2019-09-07T00:00:00+00:00

Hi all!

There was a sensation:

The presentation of the new iPhone went unnoticed!

Because we released Selenide 5.3.1. With improved shots as well. :)

We fixed only one problem in this version, but what problem is it!

Maven, where are my screenshots?

Recently we discovered that users of Maven and latest maven-surefire-plugin:2.22.2 were deprived of one of the most important selenide features: screenshot was not added to the error report.

That was unexpected!

How did you even live without it, poor fellows?

Probably that’s why you think you need BDD, Serenity and Allure? Probably you don’t need. :)

Read on.

See the difference

That’s how error report looks in Maven and latest maven-surefire-plugin:2.22.2:

com.codeborne.selenide.ex.ListSizeMismatch: 
: expected: = 11, actual: 0, collection: .results
Elements: []
	at org.selenide.GoogleTest.openGoogle(GoogleTest.java:42)

You don’t see a screenshot. Bad luck.

And this is how error report looks in Gradle, Ant, any IDE and default maven-surefire-plugin:2.12.4:

List size mismatch. Expected: = 11, actual: 0, collection: .results
Elements: []
Screenshot: file:/Users/andrei/projects/selenide-examples/sandbox-selenide-junit5/build/reports/tests/1567803355181.0.png
Page source: file:/Users/andrei/projects/selenide-examples/sandbox-selenide-junit5/build/reports/tests/1567803355181.0.html
Timeout: 4 s.
	at org.selenide.GoogleTest.openGoogle(GoogleTest.java:42)

Now you see a screenshot in case of test failure. It’s enough to investigate the reason of test failure. You just don’t need any “nice” reports, BDD, report portals etc.

Now we are talking!

Investigation

But why it happened?

In Java, there is a class Throwable which is a parent of all errors and exceptions.
It has 2 important methods: getMessage() and toString().
by default toString() = class name + getMessage()

For example, the following code

    Throwable e = new IllegalArgumentException("nope");
    System.out.println(e.getMessage());
    System.out.println(e.toString());

prints out:

    nope
    java.lang.IllegalArgumentException: nope

Initially, Selenide added screenshot name in method UIAssertionError.toString(). And it worked fine in Gradle, Ant, all IDEs. And in Maven too - in case of default maven-surefire-plugin version.

So what was updated in Maven?

There are funny guys working on Maven.

Maven has 2 plugins for tests, not one.
These plugins are named “surefire”, not “test” (which would be intuitive and clear for everyone)
The latest Maven 3.6.2 by default uses different versions of those plugins:
- maven-surefire-plugin:2.12.4 - 7 years old (e.g. doesn’t support Java 11)
- and unexpectedly
  maven-surefire-report-plugin:3.0.0-M3 - beta version, not ready for production

Now, if you upgrade to latest maven-surefire-plugin in your pom.xml:

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.22.2</version>
      </plugin>

test reports start changing. Instead of e.toString() it now uses class name + getMessage(). That’s why screenshots are not appended to error report anymore.

How we fixed it?

Simple. We now add screenshot in method e.getMessage() instead of e.toString(). Sound simple, but we had to refactor all Selenide exceptions and fix many tests.

Probably something went wrong, so feel free to file issues, if you wish some error messages to be improved!

All the background and code modifications can be found here:

News

Selenide goes over the world!

Look, what a great video created Martin Škarbala from Slovakia. In just a 1.5 minutes he demonstrates benefits of Selenide, and how much of boilerplate code you can delete after migration to Selenide.

Conferences

September, 20-21 - I will give two talks at QA Fest conference - Kyiv, Ukraine

Andrei Solntsev

selenide.org

Released Selenide 5.3.0

2019-09-02T00:00:00+00:00

We released Selenide 5.3.0. What’s new?

#968 Execute custom commands

#970 Improved error message for `shouldHave(attribute("href", ..."))`

Folks reported a strange problem: href is the same, but test fails:

Element should have attribute href="/files/hello_world.txt" {by text: Download me}
Element: '<a href="/files/hello_world.txt">Download me</a>'

The problem is with one nuance in Selenium: method WebElement.getAttribute("href") returns absolute URL, even if href contains a relative URL.

Actually we haven’t fixed this nuance, but improved the error message. Now it shows the actual value of the attribute:

Actual value: href="http://my-test-env.com:9999/files/hello_world.txt"

#469 Improved error messages for OR checks

Probably you know that Selenide allows you to check one of multiple conditions (OR operand). It’s useful when you need to check if first OR second condition is matched (or both).

    
    $("input#agree").shouldBe(or("checked", 
      attribute("checked", "true"), 
      attribute("checked", "on")
    ));

The problem was: when such a test failed, it reported an invalid error message. It included only the first condition:

Element should have attribute 'attribute checked' {input#agree}"

We have fixed it. Now it reports all conditions from OR block:

Element should be checked: attribute 'true' or attribute 'on' {input#agree}

See Issue 469 and PR 962.

Upgraded to WebDriverManager:3.6.2

It seems to have mostly fixes for Edge browser. Changelog is here.

News

Boni García (author of WebDriverManager) created selenium-jupiter - a wrapper for Selenide (+JUnit5 +Docker). Look ma, a wrapper for a wrapper!
Comparision of Selenide and FluentLenium: Part 1, Part 2
Wow! Sergei Egorov (committer of TestContainers) created a true magic: Jabel. Now you can write code on Java13 and compile it to Java8 byte code.

Conferences

September, 20-21 - I will give two talks at QA Fest conference - Kyiv, Ukraine

Andrei Solntsev

selenide.org

Released Selenide 5.2.7

2019-08-01T00:00:00+00:00

Good summer everyone!

We recently released several minor Selenide updates: 5.2.5-5.2.7.

Let me speak from my heart why we needed them.

We fixed error messages when running Selenide+Appium

Appium is a webdriver for mobile applications (AndroidDriver, IOSDriver). At a first glance, it seems to be a great idea: use the well-known Selenium WebDriver protocol for testing mobile. But many things that were “standard” and “reasonable” in web, work differently in mobile. Or do not work at all.

Appium for Selenium is like Lobachevsky’s geometry for Euclidean geometry: everything is round and through the ass.

That’s why Selenide could give illegal error messages in case of test failures. When trying to compose an error message, Selenide calls some “standard” methods which always worked in all web browsers: $.getTagName(), $.isDisplayed(), executeJavascript() etc. But which fail in Appium (either Android or iOS or both).

To fix this issue, we had to add several catch (NoSuchElementException | UnsupportedOperationException | UnsupportedCommandException | WebDriverException) blocks which are essentially needed only because of Appium. We needed versions 5.2.6 and 5.2.7 just to add another catch for another corner case.

Now Selenide works better for mobiles. Amen.

See issue 496 - Fix $.toString() in Appium

NB! You can find examples of using Selenide for mobile on github.

Added method `open()` without parameters

This method just opens an empty browser. Without a URL.

It’s also needed for mobile. Selenide 5.+ requires that browser should be opened before any operations with web elements. But the traditional method open(URL) doesn’t work in Appium - you don’t have any URLs in mobile, you have applications.

It’s a stupid situation, but we found an elegant solution, right? :)

Thanks to yaroslav-orel for PR 956.

Added method `because` for collections

As you know, to make error messages more readable, you can add a description to any condition. You don’t just say that the button is expected to be blue, but you also explain why you think that it should be blue:

$("#login").shouldBe(disabled);
$("#login").shouldBe(disabled.because("User entered a wrong password 3 times"));

Now we have similar methods for collections:

$$(".cv").shouldHave(size(3));
$$(".cv").shouldHave(size(3).because("Bob has two CVs and John has one."));

Thanks to Roman Kliuha for PR 904

Fixed problem with `open` inside of `open`

This is just an anecdotal case. You call method open(url) and get an error:

IllegalStateException: No webdriver is bound to current thread: 19. You need to call open(url) first.

Like, “you can’t call open because you have to call open”.

After a small research we found that the problem was in combination Selenide+Allure.

Selenide tried to open a browser
Selenide failed to open it (e.g. could not find Chrome executable in PATH)
Allure tried to add this even to its log
Allure tried to make a screenshot
Allure asked for screenshot from a “currently opened browser” and got an error.

See fix in

Selenide: issue 928 and PR 958
Allure: issue 379 and PR 380

News

Video Antistatic - Andrei Solntsev in DevClub.ee, Tallinn, 23.07.2019
Blog post Code simplicity

Conferences

September, 20-21 - I will give two talks at QA Fest conference - Kyiv, Ukraine

Andrei Solntsev

selenide.org

Code simplicity

2019-07-08T00:00:00+00:00

Let’s talk about simplicity of code.
Probably all of you are agree that simple code is a good code. The problem is that we all understand “simplicity” differently.

Let me show an example from one of site comments. So we can compare two variants and decide which one is simple.

A goal

There is some “Gmail”-like list with checkboxes and titles. We need a page object allowing to find by title and click one or more checkboxes.

HTML structure

is not really important, but it looks like this:

<div class="box">
  <div class="boxCheckbox">
    <input type="checkbox">...</input>  
  </div>
  <div class="boxLabel">
    Here is checkbox #1  
  </div>
</div>
<div class="box">
  ...
</div>
...

here we have several <div class="box">, each contains a pair <div class="boxCheckbox"> + <div class="boxLabel">.

The complex code

The following is a typical code that I saw so many-many times. I often think that this is nowadays automation.

import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;

import java.util.ArrayList;
import java.util.List;

public class SeleniumPageObject {

  // Search for element index in the list by title
  public static List<Integer> findListIndexesByTitle(List<WebElement> elementList, String SearchText) {
    List<Integer> ints = new ArrayList<>();
    for (int i = 0; i < elementList.size(); i++) {
      if (elementList.get(i).getText().contains(SearchText)) {
        ints.add(i);
      }
    }
    return ints;
  }

  // Buttons in the boxes
  @FindBy(xpath = "//div[@class='boxCheckbox']")
  private List<WebElement> selectCheckBoxesInBoxes;

  // Titles for boxes
  @FindBy(xpath = "//div[@class='boxLabel']")
  private List<WebElement> listOfTitlesInBoxes;

  // Select Box by title
  public void selectBoxByTitle(String searchTitle) {
    int index = findListIndexesByTitle(listOfTitlesInBoxes, searchTitle).get(0);
    selectBoxByIndex(index);
  }

  // Select Box by index
  private void selectBoxByIndex(int elPosition) {
    selectCheckBoxesInBoxes.get(elPosition).click();
  }

  // Select All Boxes by title
  public void selectAllBoxesByTitle(String searchTitle) {
    List<Integer> ints = findListIndexesByTitle(listOfTitlesInBoxes, searchTitle);
    for (int i = 0; i < ints.size(); i++) {
      selectBoxByIndex(ints.get(i));
    }
  }
}

You probably know that comments in code are not needed, and why @FindBy doesn’t make things better etc.

Just compare these two code snippets.

The simple code

I managed to convert the code above to Selenide:

import com.codeborne.selenide.SelenideElement;

import static com.codeborne.selenide.Condition.text;
import static com.codeborne.selenide.Selenide.$$;

public class SelenidePageObject {
  public void selectBoxByTitle(String title) {
    selectBox($$(".boxLabel").findBy(text(title)));
  }

  public void selectAllBoxesByTitle(String searchTitle) {
    $$(".boxLabel").filterBy(text(searchTitle)).forEach(this::selectBox);
  }

  private void selectBox(SelenideElement boxLabel) {
    boxLabel.closest(".box").find(".boxCheckbox").click();
  }
}

Don’t you think that’s SIMPLE?

The latter variant is not ideal. But it’s much shorter and simpler. It’s easy to maintain. It’s easy to read. It’s easy to understand. It’s easy to modify. At the end, it’s easy to drop it off and write from the scratch.

P.S. Have you noticed the trick? I said that I converted the code to Selenide, but the profit came mostly from simplifying selectors, removing unneeded code, using lambdas (read: contemporary language tools). You all can do it.

Appreciate the simplicity, my friends!

Andrei Solntsev

selenide.org

Released Selenide 5.2.4

2019-06-20T00:00:00+00:00

Good evening from the Summer!

While people are celebrating Midsummer Day and Victory Day in Estonia, we are releasing Selenide 5.2.4.

What’s new there?

We fixed proxy on localhost

As you know, Selenide can run its own embedded proxy server for some functions (file downloading, authorization, logging etc.). But last versions of popular browsers (Chrome72+ and Firefox 67+) started denying proxy to intercept requests to localhost (for some security reasons).

That’s why downloading of file got broken for those who run AUT on http://localhost:port (like me).

We had to dig into browser options and add tricky settings which allow proxy to intercept requests to localhost.

See PR 950.

We fixed ScreenShooterExtension for JUnit5

As you know, when Selenide throws an error (as a rule, it’s a subclass of UIAssertionError), it always automatically takes a screenshot. In most cases it should be sufficient, but sometimes people want to use their own asserts (from JUnit, Hamcrest, AssertJ etc). Generally, Selenide cannot take screenshots in these cases - otherwise Selenide would depend on all those frameworks.

But fortunately, Selenide has support for 3 most popular testing frameworks: JUnit4, JUnit5, TestNG.

Recently we found a bug in ScreenShooterExtension for JUnit5. It took screenshots only for Selenide errors UIAssertionError. But should take for NON-selenide errors. So we fixed it.

We improved error message for `$$.shouldHave(texts("1", "2", "3"))`

Method $$.shouldHave(texts(...)) allows to check texts of the whole collection of web elements. Method $$.shouldHave(texts(...)) allows to check texts of the whole collection of web elements. For example, it’s very convenient for checking a row or a column of a table. But in some (rare) cases it could report correct, but unclear error message. We improved it.

See issue 454.
Thanks to A.Smashentsev for PR 944.

Method `$.click(offsetX, offsetY)` now calculates coordinates for the CENTER of element

In addition to the “classical” method $.click(), Selenide has similar method $.click(offsetX, offsetY) for clicking with a shift. While “classical” $.click() clicks at the center of element, method $.click(offsetX, offsetY) allows to click at any point of the element.

Here the difference comes: some browsers calculate the shift from center of element, while other - from left top corner. Even Selenium documentation for class org.openqa.selenium.interactions.Actions has a contradiction on this topic:

  /**
   * Moves the mouse to an offset from the top-left corner of the element.
   */
  public Actions moveToElement(WebElement target, int xOffset, int yOffset) {
    ...
    // Of course, this is the offset from the centre of the element. We have no idea what the width
    // and height are once we execute this method.
    ...
  }

Now we officially calculate shift from the center of element.

See PR 950.

We updated dependencies

Some Selenide dependencies got updated:

WebDriverManager 3.6.1

News

Framework TestUI on top of Appium and Selenide
There was a workshop “Selenide + Selenoid” in Lviv, Ukraine. That’s cool!
And a UI Automation Cookbook “Selenide + Allure” in Mykolaiv, Ukraine. That’s also cool!
An article from LambdaTest “Selenide+IntelliJ+Maven”
An article in Japanese “Page Object with Selenide” (?)
Presentation in Japanese “E2E test automation infrastructure with DSL on Selenide” (?)
One more article in Japanese “Selenoid + Selenide + Page objects” (?)
One more article in Japanese about recording a video while running Selenide tests (?)
Ambitious presentation “Selenide vs. Selenium: The War Of Technologies”. Let the battle begin!

Conferences

June, 27 - I will talk why static methods are bad - DevClub, Tallinn, Estonia
September, 20-21 - I will give two talks at QA Fest conference - Kyiv, Ukraine

Andrei Solntsev

selenide.org

Released Selenide 5.2.3

2019-05-07T00:00:00+00:00

On May, 7 we released Selenide 5.2.3 with small but backward incompatible changes.

Don’t be afraid. Here is goes:

Added method `SelenideLogger.beforeEvent()`

Sometimes we need to log something BEFORE doing an action. For example, to write a log before any click. Selenide has interface SelenideLogger, but it always had only one method onEvent() which works AFTER an action. Now we added method beforeEvent. And renamed onEvent to afterEvent to make api cleaner.

Thanks to pavelpp for PR 927!

NB! This change is backward incompatible.

If you implemented SelenideLogger in your project, you need to rename/add method in your implementation.
If you use library selenide-allure, you need to wait for its newer version with this PR.

Now you can open a blank page

Sometimes we need to open a blank page in test. For example, to stop all running Ajax requests from a previous test and start a new test from the scratch.

Now you can use command open("about:blank") (before version 5.2.3, Selenide added baseUrl in the beginning of the address).

See issue 914 and PR 915.

Refactoring: we extracted all `Condition` implementations to separate classes

Just for your information. For most Selenide users, it doesn’t change anything.

See PR 912.

Updated dependencies

one: WebDriverManager 3.4.0 (incl. support for Chrome 72, 73, 74)
two: HtmlUnit 2.34.1
three: HtmlUnitDriver 2.34.0

Known issues

Two last versions of Chrome and Chromedriver (73 and 74) don’t work with BrowserMobProxy running on localhost. We don’t know why.

It causes malfunctioning of downloading files and BasicAuth through proxy. Don’t you have the same problem?

Currently we don’t have a better idea than just running tests on Chrome 71.

News

Wow, Selenide got to some TOP-5!
Top 5 Java Test Frameworks For Automation In 2019
Selenium worst practices (officially, from the authors of Selenium!)
Post about Selenide in Spanish!
Part 1 and part 2.
Post about Selenide+Allure: Adding Masala to the Selenide Test Automation Framework with Allure.
One more tutorial for beginners from LambdaTest company:
Selenium Tests Using Selenide, IntelliJ, And Maven
Post about Selenide+Allure+Cucumber+Maven in Japanese: GUI test automation and result visualization.

Conferences

I will present in Kiev, Ukraine at September, 20-21 on QA Fest conference. You are welcome!
Wow. Hima Bindu Peteti talked about Selenide on SauceCon conference in Austin, Texas.
She will also present Selenide in England on DevTEST Conference:
BDD with Selenide

Andrei Solntsev

selenide.org

Released Selenide 5.2.0

2019-02-19T00:00:00+00:00

Good evening!

Now we are publishing press release of Selenide 5.2.0 which was released 19.02.2019.

Let’s quickly read what was changed there, and move on to the next versions.

Added aliases for Kotlin

Since symbols $ and $$ cannot be used as method name in Kotlin, using Selenide in Kotlin initially was not as pleasant as in Java. Here you can see some examples of how it could be solved.

After long discussions and researches, we decided to add simple aliases for Selenide methods $ and $$: element and elements. It’s a little bit longer than $, but the result is human-readable:

element(".header").shouldNot(exist)
elements(".header").shouldHave(size(3))

See issue 865.

Thanks to Jacek Kromski for PR 870!

Added check for selected text

Now you can check that an element has expected selected text:

  $("textarea").shouldHave(selectedText("oo ba"));
  $("textarea").shouldHave(text("foo bar"));

See issue 766.

Thanks to symonk for PR 876!

Improved support for `chromeoptions.args` and `chromeoptions.prefs` system properties

Actually, I am not sure if it’s a useful feature. Probably it’s easier to just implement WebDriverProvider. But still, we improved it.

Thanks to Alexei Vinogradov for PR 883.

Remove an old hack for Chrome maximization

Older versions of Chrome driver could not maximize the browser window. That’s why Selenide had a special hack to maximize Chrome. Now it’s not needed anymore, and we removed the hack.

See issue 838 and PR 901.

News

Comparative analysis: Selenide vs Geb
Neodymium: a new framework based on Selenide from Xceptance (Germany)
Post 1 | Post 2
Akita: testing framework based on Selenide from Alfabank - one of biggest banks in Russia
Post about layout testing with Selenide from Alfabank
Post about BDD with Selenide: BDD: Writing an Automated Test Suite isn’t Rocket Science
And one more post about BDD with Selenide+Cucumber

Andrei Solntsev

selenide.org

Released Selenide 5.1.1

2018-12-31T00:00:00+00:00

Good night!

With a big lag and regret, we are publishing press release of Selenide 5.1.1 Let’s quickly read what was changed there, and move on to the next versions.

Selenide allows clicking on transparent elements

Until now, Selenide didn’t allow clicking elements with opacity: 0. It seemed reasonable because real user cannot click element which he cannot see. But we found that sometimes it’s useful - e.g. when there is a file upload field behind the transparent element.

Now we don’t forbid it. :)

See issue 201

Thanks to Alexei Vinogradov for PR 874 and Alexei Barantsev for patient explanations of how Selenium really works. :)

Fixed NPE when custom webdriver is run without proxy, but user asks for proxy

Now instead of NullPointerException you will see human-readable

IllegalStateException: config.proxyEnabled == true but proxy server is not started.

See issue 878 and PR 888

Now you can switch between two webdrivers as many times as you wish

It worked correctly in Selenide 4.x and earlier, bug was broken in Selenide 5.0.0. Now we fixed it.

See issue 867 and PR 890

Selenide generates unique folder for every downloaded file

Until now, Selenide used to download all files to folder build/reports/tests with their original names. It could cause a problem when two parallel tests tried to download files with the same name.

Now Selenide will download every while to a unique folder build/reports/UUID (but still with its original name, because sometimes the file name is important).

See issue 892 and PR 893.

Upgraded to selenium-java 3.141.59

It’s so called “Pi” version of Selenium: 3.141.59 It seems to be the last Selenium version in 3.x line - the following is Selenium 4.0

See selenium 3.141.* Changelog

News

3 cool articles from Selenide committer Aliaksandr Rasolka
- how to setup project with Gradle, JUnit5, Allure and Selenide, and see code on
- How to speed up tests with fast authorization
- How to speedup authorization with help of LocalStorage
An old but good presentation Page object with selenide
The historical moment: somebody defended Master’s Thesis about Selenide:
“Development of Selenide Page Object class generator”

Andrei Solntsev

selenide.org

Released Selenide 5.0.1

2018-11-07T00:00:00+00:00

Good morning! A month has passed since the release of Selenide 5.0.0. We haven’t got any bug reports. :)

So, we have released Selenide 5.0.1 with minor fixes for old issues.

Generate random file name for downloaded file

As you know, Selenide has a method for direct file download by link:

File image = Selenide.download("https://utdirect.utexas.edu/apps/pts/parking/citations/nlogon/images/6584836/");

It tries to get file name from http header or url. If neither is present (as in example above), it failed. Now it doesn’t fail anymore, but generates a random file name. Though I would consider it as the application bug.

See issue 840 and PR 856.

Thanks to David Phillips for a solution idea.

Fixed `IndexOutOfBounds` when parent element is not found

This line caused IndexOutOfBounds before, but now it returns false:

$$("not-existing-locator").first().$$("locator").isEmpty();

See issue 747.

Thanks to Denys Shynkarenko for PR 837.

Fixed `ClassCastException` in method `$$.toArray()`

This code caused ClassCastException before:

List<SelenideElement> selenideElements = new ArrayList<>();
selenideElements.addAll($$("#table1 td"));

I don’t even want to know why somebody should need such code in tests… But well, we had to fix it, and we fixed it.

See issue 844.

Thanks to Boris Osipov for PR 847.

Added support for chrome 70

Starting from version 3.0, WebDriverManager became flaky. It contains file versions.properties which matches versions of webdrivers and browsers. But WDM gets updates much less frequently than browsers and webdrivers. Naturally, every time when new version of Firefox or Chrome gets released, WDM doesn’t support it.

By now, we added own version of versions.properties to Selenide. Selenide is updated more frequently than WDM. :)

We already added chrome70=2.42 and firefox62 there. We need your ideas how to deal with it in future. Feel free to share your thoughts!

See PR 855.

Upgraded to selenium-java 3.141.5

Changelog of selenium 3.141.*

Selenide download statistics

Downloads count continues growing. We crossed the line 40800 downloads per month!

Conferences

If you haven’t been yet, I recommend to go to Heisenbug conference in Moscow (December 2019).

It’s a really great conference. Believe me, I have been there last year.

Andrei Solntsev

selenide.org

Released Selenide 5.0.0

2018-10-10T00:00:00+00:00

It finally happened! We released a major Selenide version 5.0.0

The biggest change in Selenide 5.0.0 is a global refactoring. This is internal change. It should not (almost) affect you. For those who are interested - I am going to share refactoring details in a separate post.

What changes are waiting you in Selenide 5.0.0?

You can open two browsers in test

First of all: don’t use this feature!
In most cases, it’s a bad idea to open two or three browsers in a test.

Typically people want it to test multi-user scenarios. Something like that:

In one browser, open an admin panel and modify some setting

In other browser, open a user page and verify that the setting has been applied correctly.

The right solution in this case is to test admin panel separately, and user page separately. Don’t mix different tests into one. When you need to setup environment for test (incl. changing any settings or emulating input from other user), you can use whatever tools (rest call, insert into database etc) but not through UI. You are testing UI - it means that you are not allowed to trust UI.

If you still want to use bad practice, the API looks like this:

SelenideDriver browser1 = new SelenideDriver();
SelenideDriver browser2 = new SelenideDriver();

browser1.open("https://google.com");
browser2.open("http://yandex.ru");

browser1.$(h1).shouldHave(text("Google"));
browser2.$(h1).shouldHave(text("Yandeks"));

See actual example in Selenide own tests

See issue 354 and PR 801

My thanks go to people who played an important role in this long-running refactoring:

Iakiv Kramarenko for the initial idea,
Alexei Barantsev for constructive and convincing arguments,
Aliaksandr Rasolka for moral support and idea generation.

NB! Old good open, $, $$ still work, and I still recommend to use them. They do use new SelenideDriver() inside, but they correctly store and destroy it. You just don’t need to reinvent the wheel and solve the same problems again and again.

Let me repeat myself: two browsers in one test is most probably a BAD PRACTICE!

Now Selenide uses Chrome by default

Many years ago, we chose Firefox as a default browser because it was the only browser which did not require installation of a webdriver binary. Nowadays this argument is not valid because 1) Firefox now also requires installation of geckodriver, and 2) Selenide can install webdrivers automatically.

From our experience, Chrome is faster and more stable. That’s why now is Chrome Era.

See issue 811 – thanks to Aliaksandr Rasolka for PR 812

Selenide does not maximize browser by default

At the beginning it seemed to be a good idea to open browser to the full screen size. It should make tests stable: more elements fit to the screen. Many people still think this way.

Actually it makes tests flaky because tests result depends on screen size which is a random uncontrollable variable. Our new recommendation to set browser size explicitly to the minimal size supported by your application.

Selenide 5.0.0 by default sets browsers size to 1366x768 because it is worlds’ most popular resolution by the moment. As usually, you can redefine it as any other setting.

See issue 810 – thanks to Aliaksandr Rasolka for PR 812

Selenide doesn’t open a browser automatically

Methods $ and $$ now throw an exception if browser is not opened yet (or is already closed). The right way is to open a browser first (by calling open(url)) and then search elements ($, $$ etc).

Before this release, methods $ and $$ opened a new browser automatically if it was not open yet. This behaviour could be unexpected sometimes. For example, people got Firefox when they expected Chrome. Or got two browsers when they expected one. Yes, it was a bug in tests, but now Selenide helps to find it faster.

There are known cases when tests started failing after upgrade to Selenide 5.0.0 for two reasons:
Page object fields were declared static, and browser was closed after every test. Static fields were initialized only once. Every following test didn’t re-initialize them, but got from a previous test SelenideElement instances containing a reference to (already closed) webdriver. Solution: make page object fields non-static. Static is evil.
Test class fields (in case of TestNG) were initialized in field declaration, not in setUp method. That’s why I love JUnit. Happy JUnit users can afford such a luxury:
public class MyTest {
  SelenideElement header = $("h1");
}
But poor TestNG users are forced to move initialization to @Before-like methods:
public class MyTest {
  SelenideElement header;
  @BeforeEach
  public void setUp() {
    header = $("h1");
  }
}
Looks ugly, right? My advice: forget TestNG. JUnit rules.

See issue 809

Cleaned up unused settings and features

See issue 806 – thanks to Aliaksandr Rasolka for PR 812

Among other changes, we removed the following settings:

browser (use selenide.browser instead)
remote (use selenide.remote instead)
selenide.browser-size (use selenide.browserSize instead)
selenide.browser.version (use selenide.browserVersion instead)
browser.version (use selenide.browserVersion instead)
selenide.start-maximized (use selenide.startMaximized instead)
selenide.chrome.switches (use selenide.chromeSwitches instead)
chrome.switches (use selenide.chromeSwitches instead)
selenide.page-load-strategy (use selenide.pageLoadStrategy instead)
selenide.click-via-js (use selenide.clickViaJs instead)
selenide.reports (use selenide.reportsFolder instead)

Removed `junit5-api` api dependency

Selenide transitively pulled junit5-api dependency to your project, even if you don’t use JUnit5. Apparently you don’t want it. Now it doesn’t.

If you use JUnit5 and some classes disappeared from classpath after upgrade, you will need to add JUnit5 dependency explicitly: "org.junit.jupiter:junit-jupiter-api:5.3.1".

And minor changes:

Classes AssertionMode, SelectorMode, FileDownloadMode moved from class Configuration to package com.codeborne.selenide.
Now Selenide throws ElementIsNotClickableException instead of ElementNotFoundException (if element could not be clicked because it was covered by another element).
Selenide throws error if Configuration.fileDownload == PROXY but Configuration.proxyEnabled == false. You will need to explicitly set Configuration.proxyEnabled=true to download files via proxy.
817 fix “FirefoxDriverFactory overwrites Firefox profile provided by Configuration” – thanks to Boris Osipov for PR 821
bugfix: method Selenide.download() should not fail if there is no opened browser yet
825 Upgraded WebDriverManager to 3.0.0 (again)
825 Created a workaround for WebDriverManager, so that it doesn’t call github api too often (getting 403 error)
832 Added support for screenshots outside of “user.dir” in CI server – thanks Alex Yu

Technical changes (which probably will not affect you)

Upgraded to htmlunitdriver 2.33.0
Moved constants IE, FIREFOX etc. from class WebDriverRunner to its parent class Browsers
Moved classes Selenide, WebDriverRunner, Configuration to subfolder statics.
Moved default settings initialization from Configuration to SelenideConfig.
when waiting for a condition, catch explicitly only needed exceptions instead of Throwable which is too generic. It does not make sense to wait for 4 seconds in case of IllegalStateException, FileNotFoundException etc.

News

We moved Selenide project to a dedicated github organisation: github.com/selenide
Just a reminder: selenide usage examples with different frameworks are located in a separate organisation github.com/selenide-examples
We created a Selenide project template for Gradle
A video from my DevCon 2018 speech was published: Selenide: fall in love after 15 slides
Boring comparision: Selenide vs. Selenium: The War Of Technologies!!!
16.10.2018, Krakow, Agile & Automation Days - Selenide master class, Aleksei Vinogradov
7.11.2018, Belgrade, Test Conference - Rapid UI-Test automation with Selenide, Aleksei Vinogradov
18.10.2018, Moscow, anonymous automation engineers meetup - Configuration in tests. Gradle, Java, Selenide, Boris Osyanin
Tomorrow there is a meetup in America - BDD with Selenide - 16.10.2018, Reston, VA

Selenide is an open-source library that can make a huge impact on and accelerate software delivery by introducing a concise API, shorter expressions, and many other capabilities.

We get 7 years old!

Time does go on. Could we imagine that? Selenide gets 7 at October, 25. Now it’s funny to look at the first commits:

How your upgrade went?

Share your experience, register github issues, discuss your problems in slack and gitter.

Andrei Solntsev

selenide.org

Released Selenide 4.14.0

2018-08-29T00:00:00+00:00

On August 29, 1997 a computer system Skynet became self-aware and launched nuclear missiles at Russia. So the war between humans and terminators began.

It happened .. oh, my god! - 21 years ago. And since we are still alive, we decided to release Selenide 4.14.0 at this historical day.

There is not so much changes, and they are mostly about Selenide proxy server.

We implemented BasicAuth through proxy

Test servers are often password-protected (so called BasicAuth). (I really don’t understand why it’s needed: they are in intranet anyway! But nothing to do, people do it.)

Until today, Selenide could only bypass BasicAuth by adding username:password@ to URL. But folks say that it doesn’t always work in some browsers. Now we implemented BasicAuth through selenide proxy server instead of URL. Roughly speaking, Selenide adds a http header Authorization: Basic foobar to every request from browser to application. This way definitely works in all browsers. So go enable proxy in your tests (see next chapter).

See issue 784 – thanks to Aliaksandr Rasolka for PR 785

We added a dedicated setting to enable/disable proxy server

As you know, Selenide can run its own built-in proxy server which tracks requests between browser and application under test. Initially, it was used only for downloading files. That’s why Selenide didn’t have any special settings for proxy - it was be enabled just by setting Configuration.fileDownload == PROXY.

Now proxy server is used for more different features (see previous chapter), and more is coming.

That’s why we added a dedicated setting to enable/disable proxy server:

Configuration.proxyEnabled = true | false (default value: false)

Let me explain why false is by default. I personally recommend to enable proxy server. It’s a good guy. It allows us features that are not possible with plain selenium.

Proxy will not work only in one case. When tests and browser are run on different machines, and the “tests machine” is not visible from the “browser machine”. I hope it’s not the case for most of you. I don’t really understand why people need to create barriers between test servers in intranet. But well, bloody enterprise do it, you know… :( That’s why we put proxyEnabled to false by default.

There are couple of settings for fine-tuning proxy server (not needed for most of you):

Configuration.proxyHost
Default value: "" (Selenide will automatically put IP or host of local machine)
Configuration.proxyPort
Default value: 0 (Selenide will automatically pick a random free port on local machine)

See issue 788 and PR 791

We removed an old IE-specific hack

When running tests in IE, Selenide always added a ?timestamp=somerandomnumbers parameter to every URL. It was a hack to force IE reload pages. It was a long time ago. At that time, it seemed that IE sometimes didn’t reload content on click, but got it from cache.

Now I think that the reason was somewhere else, not in IE. And this hack is not really needed. So we removed it.

See issue 789 and PR 790

News

We got updated download statistics for Selenide. It’s awesome! We achieved 37000+ downloads per month!

What do you think?

Feel free to share your ideas how we can use proxy server. Let’s discuss it!

Andrei Solntsev

selenide.org

Released Selenide 4.13.0

2018-08-20T00:00:00+00:00

Hi all!

On August 20, Estonia marks a unique holiday - the Day of Restoration of Independence. 08/20/1991 Estonia regained its independence. Right now, outside the window, a many-thousands-strong choir sings patriotic songs and thunders salute.

And I am rolling out to the sounds of the salute … Selenide 4.13.0

There were more changes than it seemed to me. :)

Added method `$.lastChild()`

It finds the last child element of given element. Like $("table").lastChild().shouldHave(cssClass("lastRow"));

See examples in Selenide tests

Thanks to SymonK for PR 771

Added collection checks with custom timeout

As you know, Selenide always had method $.waitUntil(condition, timeout) for waiting for some event with non-standard timeout. Now we added similar method for collections. Though, we decided not to name it waitUntil, because this name doesn’t match well with condition names: $$.waitUntil(texts("a", "b", "c")) doesn’t sound well in English. Instead, we use the same name as before:

$$.shouldBe(empty, 9000)
$$.shouldHave(size(4), 9000)

See more examples in Selenide tests.

See issue 601 and PR 781

Added method `Selenide.download(url)`

It downloads a file by direct link. But downloads as it was downloaded by browser. Technically speaking, Selenide performs Http GET request with your provided URL, but adds cookies and User-Agent header from currently opened webdriver.

See more examples in Selenide tests.

See PR 782

Upgraded to Selenium 3.14.0

Just in case, I have to mention that SelenideElement doesn’t implement the following deprecated interfaces anymore:

FindsByLinkText
FindsById
FindsByName
FindsByTagName
FindsByClassName
FindsByCssSelector
FindsByXPath
HasIdentity

I believe it will not affect you. Just in case.

See PR 773

Method `switchTo().alert()` now throws `NoAlertPresentException`

… instead ofTimeoutException

See issue 273 – thanks to Keita Tsukamoto for PR 774

Fixed error message from `$.selectOptionByValue()`

See issue 709 – thanks to Keita Tsukamoto for PR 780

Fixed name of downloaded file

See issue 734 – thanks to Aliaksandr Rasolka for PR 768

Upgraded to WebdriverManager 2.2.5

See PR 783 and WebdriverManager changelog

Upgraded to HtmlUnit 2.32.1

See PR 775

Fixed Selenide own tests Firefox

Probably you remember the historical moment when webdriver for Firefox already didn’t work, but Geckodriver (aka Marionette) didn’t work yet. At that moment we had to “temporarily” disable Selenide own tests in Firefox. And recently we discovered that there have been disables for last N years :(

Now we finally enabled them back and fixed. We had to fix quite a lot of things… We probably even fixed some Firefox-specific bugs. :)

See PR 778

News

A great fragment of a phrase in a chat:

I use Java not only for being Java, but also for existing sweeties: Selenide, RestAssured etc.
We discovered two new frameworks, both powered by Selenide:
- Selenium Automation Bundle
- Neodymium
You can generate a new Selenide + Maven + JUnit5 sample project with just one line!

For example:

mvn archetype:generate -B
  -DarchetypeGroupId=org.selenide -DarchetypeArtifactId=selenide-junit5-archetype
  -DgroupId=com.example -DartifactId=ui-tests -Dpackage=com.example.project.ui

See Maven Archetype Documentation for further instructions.

I’ll be back!

Andrei Solntsev

selenide.org

Released Selenide 4.12.3

2018-07-17T00:00:00+00:00

Good day! The championship is finally finished, and we can get back to our favorite open-source projects.

Today we released Selenide 4.12.3

Let’s look what’s inside!

Added support for JUnit 5

As you know, Selenide has special support for the most popular testing frameworks: JUnit4 and TestNG. It means special “@Rules” or “Listeners”, which can periodically restart a browser, make screenshots etc.

Now we added similar support for JUnit 5 too:

BrowserStrategyExtension
ScreenShooterExtension
SoftAssertsExtension
TextReportExtension

Thanks to Aliaksandr Rasolka for PR 757

By the way, we have also rewritten Selenide own tests to JUnit5 and AssertJ. So you can look for JUnit5 examples there if you need.

Timeout for downloading files

As you know, Selenide has method $.download() for downloading files. It uses the standard setting Configuration.timeout to avoid too slow/hanging downloads.

But some files are expected to download slowly. For example, when generating some heavy reports. For such cases we added a download method with timeout parameter:

File hugeReport = $("#huge-report").download(100500);

See issue 758 - thanks to Yuri Ivanov for PR 761

Collection reloading on every method call

This changes caused hot discussions.

Collection is a list of matched elements returned by method$$. It returns ALL matched elements. Sometimes this list can be long. Sometimes it can make tests slower.

Before

Before version 4.10.1, Selenide always loaded the whole collection on every method call. That’s why a trivial iterating over big collection (few hundreds of elements) could be slow:

$$("span").forEach(item -> item.is(visible));

After

From Selenide 4.10.1, we started caching collections. The iterating became faster, but we got new complains. Some people store collection to a variable and do expect that it will be reloaded all the time:

ElementsCollection movieTitles = $$(".film");
assertEquals("Black Panther", movieTitles.get(0).getText());
$(By.name("sort")).selectOption("Release Date");
assertEquals("The Irishman", movieTitles.get(0).getText());

In my opinion, this code is unnatural: if I expect the collection to be changed, it would be natural to call method $$ once again. That’s why I didn’t want to revert caching for some time.

But finally, “consistency” argument won. Method $ does reload element on every method call, so $$ should behave the same way.

Now

So we chose a compromise: $$ reloads the collection on every method call except $$.iterator() and $$.listIterator(). So the iteration will be fast, and elements will be reloaded (almost) always. I don’t know if it was the right decision. The new behavior can also cause some unexpected effects and pains. We will see.

$$.snapshot()

By the way, if you want to cache the collection explicitly, we added method $$.snapshot(). It returns a current state of the collection - “snapshot”. It will not reload collection elements anymore. Iterating and any checks will be faster. You can you use this method when you know that the elements will not be loaded dynamically.

See issue 696

News

We found a presentation about Selenide by Alexander Bondarev from Determine from some Nerd’s Day at Provectus. There is also a video.
It finally happened! Selenide got to some Technology Radar with a title “Selenide as new standard”. See source
Welcome to Agile Automation Days October 15-16 to see Workshop: Jump into the KISS UI-Test automation with Selenide

Stay tuned!

Andrei Solntsev

selenide.org

Released Selenide 4.12.2

2018-06-27T00:00:00+00:00

We released Selenide 4.12.2

Let’s see what was changed there.

We added method `because` for collections

As you know, Selenide has method because allowing test author to clarify why he expects this behaviour:

  $("#login").shouldBe(visible.because("After 3 wrong answers user should be logged out"));

Now we also have method because for collections:

  $$(".error").shouldHave(size(3).because("A separate error message per wrong answer"));

See issue 440 - thanks to Mikhail Sidelnikov for PR 749

Selenide will not try to open a browser

… if setting Configuration.reopenBrowserOnFail is false.

Don’t be afraid, nothing will change for most of you. This setting is true by default.

This setting was initially created for those who want to open/close browser entirely be themselves.

See issue 695 and PR 754

We upgraded dependencies

selenium 3.13.0
webdrivermanager 2.2.3

Andrei Solntsev

selenide.org

Released Selenide 4.12.1

2018-06-02T00:00:00+00:00

Good summer!

With some delay, we post the Selenide 4.12.1 release notes.

Fixed name of downloaded file

When you download a file with link containing ? and parameters (like /download/me/selenide-4.11.5.md?sessioncookie=12345), Selenide created a local file with name selenide-4.11.5.md?sessioncookie=12345.

Now Selenide will cut all characters from ?. In this case, it will create a file selenide-4.11.5.md.

See issue 735 - thanks to Aliaksandr Rasolka for PR 735

Changed implementation of method `Selenide.refresh()`

This method sometimes didn’t actually refresh the page.
We could not reproduce it, but blindly changed the implementation - now it just calls built-in selenium method
webdriver.navigate().refresh(). Seems that it fixed the problem.

See issue 740 - thanks to Aliaksandr Rasolka for PR 741

Fixed method `WebDriverRunner.isHeadless()`

This method returned true only for HtmlUnit and PhantomJS. Now it returns true also for Chrome/Firefox when executed in headless mode.

(Though I personally don’t understand why one needs to use this method. Don’t use it. Do you really need Selenide help to know what browser you have started?)

See issue 750 - thanks to Aliaksandr Rasolka for PR 751

Added thread ID to log messages on closeWebDriver() method

For some people, it was sometimes hard to understand which thread closed the driver. Now it will be easier.

(Though I personally don’t understand why it should be a problem)

See issue 582 - thanks to Alexander Poleschuk for PR 737

Declared `webdrivermanager` dependency as `api`

Now you can use webdrivermanager from your code without declaring any additional dependencies.

Thanks to Aliaksandr Rasolka for PR 736

Migrated from `coveralls` to `sonarcloud`

for measuring Selenide own test coverage. It doesn’t affect you directly, just FYI.

See issue 702 - thanks to Aliaksandr Rasolka for PR 744

Andrei Solntsev

selenide.org

Released Selenide 4.11.4

2018-05-09T00:00:00+00:00

We made a mini release Selenide 4.11.4

Removed spam in logs from Firefox driver

See issue 673 - thanks to Aliaksandr Rasolka for PR 732

Upgraded dependencies

selenium 3.12.0
gson:2.8.4
guava:25.0

Andrei Solntsev

selenide.org

Released Selenide 4.11.3

2018-05-08T00:00:00+00:00

We released Selenide 4.11.3. Let’s see what updates it contains:

You can now get access to proxy server

As you know, Selenide starts a built-in proxy server (BrowserMobProxy). But until now, you could not use it because it was private. Selenide used it only for downloading files.

Now we added a public method which allows you to get the BrowserMobProxy instance and use as you wish:

BrowserMobProxy bmp = WebDriverRunner.getSelenideProxy().getProxy();

Please tell us in comments how you are going to use it!

P.S. Selenide still starts proxy server only when Configuration.fileDownload=PROXY. Probably we will break this dependency in next version.

Thanks to Aliaksandr Rasolka for PR 731

We added condition `cssValue`

Now you can check CSS properties of elements:

$("input").shouldHave(cssValue("font-size", "12"));

See issue 628 - thanks to Aliaksandr Rasolka for PR 727

Attention! Use this check with caution. Such checks can make your tests too fragile. You don’t want to have tests that fail often just because of minor design tunings, right?

And remember that Selenium method getCssValue can return different results for different browsers. For example, you cannot just write a universal check for all browsers: $("input").shouldHave(cssValue("color", "#000000")), because

For Chrome, it is rgb(0, 0, 0)
For Firefox, it is rgba(0, 0, 0, 0)

We removed wrong dependency `logback-classic`

As you probably remember, in previous Selenide version there was introduces an extra dependency WebDriverManager -> logback, and we recommended to exclude it in your build script.

Now you can remove these lines:

  exclude group: "ch.qos.logback", module: "logback-classic"

Removed duplicate screenshots

Starting from version 4.11.0 Selenide created duplicate screenshots in some cases. Now we fixed it.

See issue 729 - thanks to Boris Osipov for PR 730

Implemented using of `browserBinary` setting in case of remote browser

Starting from version 4.9, Selenide has a setting for browser binary path - Configuration.browserBinary. But it was used only for local browser.

Now Selenide also uses this setting for remote browser.

See issue 725 - thanks to Alexei Vinogradov for PR 726

News

Another video tutorial about Selenide
See you in Kraków, May, 9-11 at GeeCon conference - I will present Selenide there.

Stay tuned!

Andrei Solntsev

selenide.org

Released Selenide 4.11.2

2018-04-25T00:00:00+00:00

Dear friends, we released Selenide 4.11.2. Below you can find the notable changes of this release.

Now you can make screenshots inside `iframe`

You can find examples in ScreenshotInIframeTest:

SelenideElement iframe = $("#iframe_page");
SelenideElement element = $("#small_div");
File file = Screenshots.takeScreenShot(iframe, element);

Thanks to Andrejs Kalnačs for PR 705

We added method `atBottom()`

Now you can check if a page is scrolled to the bottom:

assertFalse(atBottom());
executeJavaScript("return window.scrollTo(0, document.body.scrollHeight);");
assertTrue(atBottom());

You can find examples in PageAtBottomTest

Thanks to pavelpp for PR 646

We added setting `setValueChangeEvent`

As you probably know, methods $.append() and $.setValue() trigger few events after setting a value to the input field, including the change event. We recently realized that it’s wrong, because the change even should be triggered by browser.

It also caused problems in some cases - for example, when this change event caused focus moving to the next element in DOM which was actually outside of viewport.

Don’t panic, Selenide behaviour hasn’t changed by default. Default value is setValueChangeEvent=true.

If you agree with our reasoning, disable triggering change event via system property:

-Dselenide.setValueChangeEvent=false

or right in code:

Configuration.setValueChangeEvent = false;

If you disagree, feel free to share your thoughts. Let’s discuss it!

Thanks to MikeShysh for PR 718

We upgraded dependencies

htmlunit:2.30
webdrivermanager:2.2.1

If you use a custom SLF4J implementation, you may get some spam in logs like this:

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/Users/arasolka/.gradle/caches/modules-2/files-2.1/org.apache.logging.log4j/log4j-slf4j-impl/2.11.0/9ba207b78e470fe7765ebee14f1f0336c9cbcc18/log4j-slf4j-impl-2.11.0.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/Users/arasolka/.gradle/caches/modules-2/files-2.1/ch.qos.logback/logback-classic/1.2.3/7c4f3c474fb2c041d8028740440937705ebb473a/logback-classic-1.2.3.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.apache.logging.slf4j.Log4jLoggerFactory]

To remove this spam, ignore the transitive dependency of webdrivermanager:

configurations.all {
    exclude group: "ch.qos.logback", module: "logback-classic"
}

We will fix it in next Selenide version.

Statistics

We haven’t posted Selenide download statistics for a long time. And it is growing! A year ago there were 8000, now 18000 downloads in a month.

Life is going on!

Andrei Solntsev

selenide.org

Released Selenide 4.11.1

2018-04-03T00:00:00+00:00

Dear friends, We recently moved to “Semantic versioning”. Now Selenide versions will be called 4.11.x and released more often.

In Selenide 4.11.1 we did only one fix:

Fixed a problem with hanging Chrome on Windows

Windows users complained that even after calling Selenide.close() process chrome.exe still hangs in task manager. Though it’s not a Selenide bug, we managed to tune webdriver settings, so that Chrome is properly closed now.

Thanks to Aliaksandr Rasolka for PR 711!

That’s it. Selenide 4.11.2 is coming soon!

Andrei Solntsev

selenide.org

Released Selenide 4.11.0

2018-04-02T00:00:00+00:00

Good morning, my friends!

We released Selenide 4.11.0. What’s new there?

Upgraded to selenium 3.11.0
Collection condition textsInAnyOrder
Browser position
Download files with non-ascii characters
Pass chromeoptions.prefs to webdriver
Request/response interceptors in Selenide proxy
Deprecate $.followLink()
NullPointerException in SelenideReport
Screenshot for soft asserts
News
Resources

Upgraded to selenium 3.11.0

The main changes in selenium 3.11.0 are about Internet Explorer and Windows platform.

And also:

removed methods startClient and stopClient in class RemoteWebDriver
remove properties SafariOptions.cleanSession and SafariOptions.port

Added collection condition `textsInAnyOrder`

Now you can write more advanced check for collections:

$$.shouldHave(textsInAnyOrder("Push", "Image", "Email"))

See issue 478 – thanks to hyunil-shin for PR 589

Now you can set browser position

As usually, either via system property:

-Dselenide.browserPosition=300x200

or in code:

Configuration.browserPosition = "400x300";

See issue 687 – thanks to Aliaksandr Rasolka for PR 687

Now Selenide can download files with non-ascii characters in name

Now this code will work correctly:

  File file = $("a").download();
  assertThat(file.getName()).isEqualTo("файл-с-русским-названием.txt");

Before this release, Selenide created a file with name -------.txt

See issue 688 and PR 689

Now you can pass `chromeoptions.prefs` to webdriver

Similar to chromeoptions.args, now you can pass parameter chromeoptions.prefs to your tests:

-Dchromeoptions.prefs=profile.block_third_party_cookies=false,profile.avatar_index=26

See PR 692 - thanks to Tymur Kubai

Now you can add your own interceptor to Selenide built-in proxy server

People asked for this feature for a long time. And we finally did it!

getSelenideProxy().addRequestFilter("proxy-usages.request", new RequestFilter() {...});
getSelenideProxy().addResponseFilter("proxy-usages.response", new ResponseFilter() {...});

In RequestFilter and ResponseFilter subclasses you can do pretty anything that is not possible in pure Selenium: log requests/responses between browser and server, measure times, get http status, modify request or response body, inject custom JavaScript to html etc. This is the god mode in Selenide!

I hope you are going to use the god mode to make your tests more fast and stable.

As usually, you can find sample usages in Selenide own tests.

NB! Now Selenide starts its built-in proxy server only if Configuration.fileDownload=PROXY.

Probably we should break this dependency. Feel free to send your feedback.

Method `$.followLink()` was marked as deprecated

Nobody remembers why it was created 7 years ago. But now you can just use $.click() instead.

Fixed a occasional NullPointerException in SelenideReport

Nobody knows how to reproduce it, but we had to fix it.

Thanks to dkorobtsov for PR 686

We fixed a problem when Selenide didn’t take screenshot in soft asserts

See issue 655 - thanks to Boris Osipov for PR 659

News

Wow! Allure implemented Selenide support
Selenide started using “semantic versioning”. Next Selenide versions will be 4.11.1, 4.11.2, 4.11.3 etc.
Selenide got two new committers.
- Boris Osipov
- Aliaksandr Rasolka
We are growing!

Resources

Integration with Allure (including Selenide, of course)
Tutorial for beginners: An installer for Selenide
Selenide was mentioned in book Learning Vue.js 2
A talk about Selenide on AADays in Poland

And a bunch of materials about in Japanese:

70 pages tutorial
One more hello world with Selenide and a servlet
A post about a problem with sendKeys in headless Chrome and its solutions with Selenide
http://www.atmarkit.co.jp/ait/articles/1803/05/news010.html
https://qiita.com/shimashima35/items/918b26c4260e764ce90a

See you soon!

Andrei Solntsev

selenide.org

Released Selenide 4.10

2018-01-12T00:00:00+00:00

Good night, Seleniders!

We recently got a chance to merge a lot of pull requests and released Selenide 4.10

So, what’s new there?

What you get when update to Selenide 4.10?

We added method `$.scrollIntoView()`

You can use it to scroll browser to the right place. For example, it can be useful to overcome issues of some browser which cannot click an element that is outside of visible window area.

So, method $.scrollIntoView() says browser to scroll the page so that the element was in a visible area.

Method can have either boolean parameter:

$("#my-button").scrollIntoView(true);  // the top of the element will be aligned to the top
$("#my-button").scrollIntoView(false); // the bottom of the element will be aligned to the bottom

or more advanced String parameter:

$("#my-button").scrollIntoView("{block: \"end\"}");
$("#my-button").scrollIntoView("{behavior: \"instant\", block: \"end\", inline: \"nearest\"}");

Read javadoc for the details.

See issue 649

Thanks to Aleksandr Rasolka for pull request 656.

Now tou can run headless browsers on Selenium Grid

If you run tests on Selenium Grid, you can now open browsers in headless mode. You need only couple of lines to achieve that:

Configuration.remote = "http://selenium-grid-host:port/wd/hub";
Configuration.headless = true;

See issue 660

Thanks to Boris Osipov for pull request 661.

Now you can set custom capabilities for Chrome and Firefox

You can set custom capabilities in Configuration, and Selenide will use them when opening a browser:

Configuration.browserCapabilities = new DesiredCapabilities();
Configuration.browserCapabilities.setCapability(SOME_CAP, "SOME_VALUE_FROM_CONFIGURATION");

See issue 556

Thanks to Sergey Pirogov for pull request 556 and Boris Osipov for pull request 664.

We optimized performance of `$$` iteration

Some of Seleniders found that such collection iteration can be slow:

$$("span").forEach(item -> item.is(visible));

Because Selenide reloads all collection elements on every step. See issue 641

We fixed that. Now the loop should be much faster. Thanks to Artem Savosik for pull request 653.

We added “User-Agent” header when downloading a file

As you probably know, Selenide downloads files by issuing a separate http request, copying all cookies from browser to it. Sometimes it’s not enough, because application also checks User-Agent in addition to session cookie. And method $().download() didn’t work in this case.

See issue 639

Now Selenide also copies User-Agent header from browser to http request for downloading file. Method $().download() should work.

Thanks to Aleksandr Rasolka for pull request 657.

Now methods `byText` and `withText` understand unbreakable spaces

Imagine that you have such an element on a page:

<span>Hello&nbsp;world</span>

By now, command $(byText("Hello world")) or $(withText("Hello world")) could not find it. Now it can.

We improved methods byText and withText to understand non-breakable spaces, or characters &nbsp or \u00A0. Now these characters are treated as usual spaces.

See issue 597

Upgraded to phantomjsdriver 1.4.4

Which in turn was upgraded to selenium-java 3.8.1 (and doesn’t have any other changes).

Upgraded to htmlunit 2.29 and guava:23.6-jre

… just in case

News

I warmly welcome you to the great SeleniumCamp conference!

2 days, 3 tracks, 500+ attendees. And Kiev is a beautiful city.

See you on SeleniumCamp 2-3 2-3.03.2018

Happy New @Deprecated Year!

Andrei Solntsev

selenide.org

Released Selenide 4.9

2017-12-20T00:00:00+00:00

Good night!

At the very last moment of year 2017, we released Selenide 4.9.

What’s new there?

Upgraded to selenium 3.8.1

There are backward-incompatible changes, be prepared. Selenium guys like to delete existing functionality :)

Thanks to Aleksandr Rasolka for pull request 638.

Now marionette is used by default

As you know, Selenide initially used Firefox as a default browser. The reason is simple: it was the only webdriver that didn’t require downloading a separate binary to drive the browser.

Later the situation changed. FireFoxDriver doesn’t support newer Firefox version anymore, it was replaced by GeckoDriver (aka Marionette). It requires downloading of a separate binary file, but now Selenide can download it automatically.

So, when you don’t set browser, Selenide now uses Marionette by default (which means Firefox). Though, I personally prefer Chrome.

Thanks to Ostap Oleksyn for pull request 621.

Fixed initialization of elements inside ElementsContainer but without @FindBy annotation

See issue 617

Thanks to Artem Savosik for pull request 618.

Though, I personally don’t use ElementsContainer and recommend you not to use. Selenide allows writing page objects / page containers much easier.

Added methods `$$(“.item”).first(3)` and `$$(“.item”).last(3)`

These methods allow to get few elements from the beginning or end of list. It can be useful when the list is too long, or its length is unknown, and you need to verify only some of elements.

See. issue 623

Thanks to Ostap Oleksyn for pull request 624.

Add ability to set browser binary path using configuration parameter

Sometimes people want to run tests with different versions of the same browser. With stable chrome, Canary, nightly build…

Now you can set explicitly the path to browser binary. Either using system property:

-Dselenide.browserBinary=/usr/lib/chrome.exe

or right in the code:

Configuration.browserBinary = "/usr/lib/firefox";

Thanks to Ostap Oleksyn for pull request 627.

Fixed method `prompt()` in HtmlUnit

Thanks to Anton Aftakhov for pull request 634

Upgraded dependencies

webdrivermanager:2.0.1
guava:23.5-jre
httpcore:4.4.8
htmlunit-driver:2.28.2

News

How to run Selenide tests on Amazon Lambda UI Testing at Scale with AWS Lambda
My article in Java Advent Calendar: Flaky tests
Article in Japanese: Using WebDriverManager with Selenide
One more: Toward people who want to utilize Selenide
https://www.linkedin.com/pulse/awesome-reporting-vigo-selenide-kushan-shalindra-amarasiri-
An article from japanese “Selenium/Appium Advent Calendar 2017”: How to record video with Selenide and Monte recorder
An article about test reports with Selenide and Vigo Reporting

Andrei Solntsev

selenide.org

Released Selenide 4.8

2017-10-08T00:00:00+00:00

Good evening!

We released Selenide 4.8. It’s mainly a Selenium upgrade.

Upgraded to selenium 3.6

This version contains some backward incompatible changes, that’s why we decided to make a separate release.

Thanks to Ostap Oleksyn for pull request 611.

By the way, we also upgraded to guava 23.0 and org.apache.httpcomponents:httpcore:4.4.7.

Fix an error with soft asserts

Thanks to Ostap Oleksyn for fixing issue 614

That’s it. This time the upgrade should be easy.

Friendly reminder

Welcome to the Heisenbug conference in Moscow - 8-9.12.2017

I will present 2 talks on it:

Welcome to Russia!

Andrei Solntsev

selenide.org

Released Selenide 4.7

2017-09-30T00:00:00+00:00

Good evening!

We released Selenide 4.7 with the most wanted feature of the year. You’ll live the life now!

Embedded WebDriverManager

Now Selenide contains WebDriverManager - a library that can automatically download latest webdriver binary file. You don’t need to care about downloading geckodriver.exe or chromedriver.exe and adding it to PATH. Selenide will take care about it.

There is one nuance. WebDriverManager will only work if:

You use one of supported webdrivers: chrome, edge, internet explorer, opera, phantomjs, marionette or gecko.
Your code hasn’t set system property webdriver.chrome.driver, webdriver.edge.driver, webdriver.ie.driver, webdriver.opera.driver, phantomjs.binary.path or webdriver.gecko.driver.

If you use another webdriver (or a custom WebDriverProvider), WebDriverManager will not be used, and you will continue working as previously.

If you still have some question, remember that the only true information source is the SOURCE CODE!

Thanks to Sergey Pirogov and Boris Osipov for pull request 610.

Added method `prompt()`

As you probably know, there is 3 native modal dialogs in JavaScript: alert, confirm and prompt. Selenide supported alert and confirm from the very beginning, but not prompt.

Now it’s supported too:

  @Test
  public void canSubmitPromptDialog() {
    $("#login").click();
    prompt("Please input your username", "Aegon Targaryen");
    prompt("Please input your password", "qwerty");
    $("#message").shouldHave(text("Hello, Aegon Targaryen!"));
  }

Thanks to Anton Aftakhov for PR 591

Added path for html file to Selenide error message

One of the most convenient feature of Selenide is automatic taking of screenshot in case of error. When a test fails, Selenide takes a screenshot and adds its path to the error message. It’s incredibly convenient to read test report and open a screenshot with just one click. And you don’t even need to install any software like Thucydides, Allure, Report Portal etc. to have it. The most simple things are the most stable.

But there is one more less-known feature.

In addition to screenshot, Selenide also save a html source code of the page where error happened. Now we also added path to this file to Selenide error message.

Thanks to hyunil-shin for PR 590.

Now Selenide error message will look like this:

Element should have text 'Goodbye, Aegon Targaryen!' {#message}
Element: '<div id="message">Hello, Aegon Targaryen!</div>'

Screenshot: file:/.../build/reports/.../canSubmitPromptDialog/1507061177250.0.png
Page source: file:/.../build/reports/.../canSubmitPromptDialog/1507061177250.0.html
Timeout: 4 s.

Fixed concurrency issue with screenshots during parallel test run

We fixed an old concurrency issue 570 with screenshots.

Thanks to Jane Riabchenko for PR 595

Upgraded to selenium-java 3.5.3

We noticed that that selenium-java released version 3.6.0, and we are going to start using it in Selenide 4.8 which is going to be released soon.

Upgraded to browsermob-core 2.1.5 (and littleproxy 1.1.0-beta-bmp-17)

It can only affect you if you download files via proxy server.

Upgraded htmlunit from 2.24 to 2.27

Thanks to Alexander Kotlyar for PR 609.

News

Welcome to the Heisenbug conference in Moscow - 8-9.12.2017

I will present 2 talks on it:

Welcome to Russia!

Andrei Solntsev

selenide.org

Released Selenide 4.6

2017-09-09T00:00:00+00:00

Good night!

We released Selenide 4.6

Method `$.shouldHave(exactValue(" foo "))` does not trim leading/trailing spaces anymore

As you probably know, method $.shouldHave(value(" foo ")) (which we all typically use) trims leading/trailing spaces in the given string. It’s convenient because web browsers also do so. But we recently found that method exactValue() also do it, and that’s not right.

Assuming that you have <textarea value="Regression test description "></textarea> on a page, the check $("textarea").shouldHave(exactValue("Regression test description ")); failed before this release. Not it will not.

See. issue 573

Thanks to @mseele for the pull request!

We added method `$.getSearchCriteria()`

Selenide always had a convenient method $.toString() - it prints actual description of a web element: tag, text, attributes. It’s very useful for logging and debugging. Bit it has one drawback: it calls webdriver methods to get those data, which can be slow sometimes.

So we added method $.getSearchCriteria() that doesn’t call any webdriver methods, but just returns a locator.

Simply said,

  assertThat($("h2").toString(), equalTo("<h2>Dropdown list</h2>"));
  assertThat($("h2").getSearchCriteria(), equalTo("h2"));

Fixed issue 528

Thanks to @BorisOsipov for the pull request!

Fixed issue 484

Sometimes Selenide could throw such an error without screenshot:

Element not found {#valid-id.findBy(text 'INVALID-TEXT')}
Expected: text '9802222-99LX'

Screenshot: null
Timeout: 0 ms.

We fixed it.

Fixed running IE on selenium grid

(OMG, does somebody still use IE and Grid in 21st century?)

See. issue 529

Thanks to @BorisOsipov for the pull request!

News

http://www.devmedia.com.br/api-selenide-desenvolvimento-de-testes-funcionais-em-java/33680
http://katrinatester.blogspot.com.ee/2017/05/three-styles-of-automation.html
http://www.autotest.org.ua/selenide-quick-start-in-automation-testing/
https://sweftt.com/en/2017/02/07/selenide-tests-maven-way/
http://qiita.com/radiocat/items/7440c4f8da2101e13761
http://codezine.jp/article/detail/10335?utm_source=dlvr.it&utm_medium=twitter
http://automation-remarks.com/2017/allure-without-annotations/

Andrei Solntsev

selenide.org

Released Selenide 4.5

2017-06-26T00:00:00+00:00

Good evening!

We released Selenide 4.5! This release is mainly dedicated to performance improvements of Selenide itself.

Speed up method `$.setValue()`

Selenide had a cool feature… that nobody knew about. Method $.setValue() pretended to be smart so much it could set value not only to text inputs, but also to selects and radio buttons. The idea was that test should remain stable even if developers change element’s type (say, from <select> to <input type="radio">).

But this “smartness” is not for free: during every call to $.setValue() Selenide tried to detect element type, calling several webdriver methods for it. It took tens or hundreds of milliseconds.

Since no one knew about it and did not use it, we decided to abandon this feature for the sake of performance. Now this “smart” behaviour of $.setValue() is disabled by default. If somebody should still need it, the following setting enables it:

-Dselenide.versatileSetValue=true

Though, there are simpler alternatives:

either enable -Dselenide.fastSetValue=true,
or use methods $.selectOption() and $.selectRadio().

Thanks to Alexander Popov for the improvement!

Speed up collection methods

Selenide also pretended to be smart when working with collections. For example, the following check:

$$("tr").shouldHave(size(7));

would wait for some time (600 ms by default), even if collection already has 7 elements. Because “probably there will be loaded more elements soon, and test should fail then”.

We also decided to abandon this feature for the sake of performance.

See pull request 549

Added methods `$().$x()` and `$().$$x()`

… for searching by XPath inside a web element.

Now you can write like this:

  $("table").$x(".//tr").shouldBe(visible);
  $("table").$$x(".//tr").shouldHave(size(5));

Thanks to Oleksii Cherevatyi for this addition!

Fix support for Opera driver

Thanks to Roman Marinsky for the fix!

Remove unneeded logs

Namely, we removed this message (when Selenide closes a webdriver):

INFO: Close proxy server: 24 -> null

Thanks to Andrew Zakordonets!

Upgraded to org.littleshoot:littleproxy:1.1.2

This applies only for those who uses option Configuration.fileDownload=PROXY.

Upgraded to phantomjsdriver 1.4.3

Added lots of unit-tests for Selenide itself

This is my personal happiness.

Andrew Zakordonets wanted to help the project and wrote a lot of missing unit-tests for Selenide itself. This is cool. Thank you Andrew!

News

We started project `selenide-appium`

We created a separate project for better Selenide support for Appium framework: github.com/selenide/selenide-appium

This is only a beginning, but the project actually works. It’s already used in at least one real-life project for testing mobile applications.

We added more projects to Selenide examples

As you probably know, there is a series of mini-projects on github - samples of using Selenide with different tools. Recently we added couple of new samples:

We are working on new samples. Probably it will be Spring Boot, Allure 2 or something else. Feel free to send your own samples!

How can YOU help Selenide?

Dear friend! You can also help Selenide project. You don’t need to be a mature developer with 20 years of experience. No. Good will is the key for success.

For example, we would be very appreciate if you:

Review open pull requests and comment if we should merge these changes to Selenide
Review open issues and comment:
- is it weird or reasonable question/feature request
- is it already done
- should we implement it
Write some missing documentation
Write some blog post
Write some missing tests for Selenide
Add your own examples of using Selenide with other tools on github.com/selenide-examples
Find a volunteer designer to helps us with selenide.org (first of all, with mobile version)

Any help is appreciated!

Andrei Solntsev

selenide.org

Released Selenide 4.3

2017-02-09T00:00:00+00:00

Hi all!

Good news: we released Selenide 4.3

Fix method `$$().find()`

More exactly, it always could find elements correctly, but it gave a misleading error message in case element could not be found.

Now it’s fixes and gives correct error message.

See. pull request 426

Thanks to Julia Iluhina for the fix!

Fixed page object fields `SelenideElement` without `@FindBy` annotation

Surprisingly, we found that Selenide could behave unexpectedly when you tried to use it unexpectedly. :)

Let’s assume that you have a page object with field of type SelenideElement (without @FindBy annotation):

class StartPage{
  SelenideElement startPage = $("#start-page");
}

This class is beautiful. It’s very simple and clean. It works out of the box without any fabrics and other utilities. You just need to create it: StartPage page = new StartPage(); - and it works. This is just idea page object that is only possible in Selenide universe.

But sometimes people still try to initialize it with page or some other factory methods, like this:

  StartPage page = page(StartPage.class);

and here problems come… See pull request 443

But now it’s fixed. Thanks to Sergei Pirogov for the fix!

Aligned system property names with Configuration fields

As you probably know, all Selenide settings can be set in two ways: either via system property or directly in code. But we found that some of them had different names. It was somewhat misleading.

Now we aligned system properties names with Configuration fields. e.g. Configuration.someProp always has system property equivalent selenide.someProp

Old names still supported for backward compatibility.

Deprecated method `Selenide.selectRadio`

In Selenide, it was possible to select a radiobutton this way: selectRadio(By.name("me"), "cat"); Now we marked this method as @Deprecated. You can use a “standard” Selenide method instead:

$(By.name("me")).selectRadio("cat");

Created constant link to latest javadoc

Now the latest javadoc is always available at this link:

selenide.org/javadoc/current/

Upgraded dependencies

upgraded to browsermob-core:2.1.4
upgraded to org.apache.httpcomponents:httpcore:4.4.6
upgraded to guava:21.0

News

Historical moment! BrowserStack wrote a tutorial how to run Selenide tests in their cloud:
BrowserStack+Selenide
Yakiv Kramarenko workshop in San-Francisco: Kiss PageObjects
New article about Selenide in Japan: I tried writing a test code with Selenide
Selenide and GEB Comparision in Japan: Selenide as seen from Geb usage
And one more tutorial in Japan: Kotlin+Selenide

Let’s upgrade!

Andrei Solntsev

selenide.org

Selenide 4.2.1 released

2017-01-26T00:00:00+00:00

Hi!

This is a bugfix and enhancements release following “4.2(Browsers)”

Fixed usage of boolean/integer capabilities as command line system properties.

Since this release capabilities values are automatically converted to boolean/integer if transferred in SystemProperties, so for example the following parameters will be working fine

-Dcapabilities.rotatable=true
-Dcapabilities.elementScrollBehavior=1

Firefox: support for FirefoxProfile preferences over command line

Good news for users who need to transfer FirefoxProfile preferences to the WebDriver. firefoxprofile.* are now automatically processed by Selenide and transferred to Firefox and Marionette drivers.

Example:

-Dfirefoxprofile.browser.startup.homepage=http://www.google.com

Consult the list of available profile preferences with actual Firefox documentation.

Chrome: support for ChromeOptions arguments over command line

Also chrome users benefit. ChromeOptions arguments are now applicable without need to extend classes. chromeoptions.args=<comma-separated-args> are automatically processed by Selenide and transferred to Chrome driver. Multiple arguments are separated by comma. At the same time Configuration.chromeSwitches and -Dselenide.chromeSwitches are deprecated as they only allowed a single argument.

Example:

-Dchromeoptions.args=--diagnostics,--disable-blink-features

Consult the list of available arguments with actual Chrome documentation.

Best automation with 4.2.1!

Alexei Vinogradov & Selenide Community

Selenide 4.2 released

2016-12-30T00:00:00+00:00

Hi!

With 4.x we’ve just started to add useful features for communication with the constantly changing environment, and in this version we made a great step forward in supporting browsers.

Support of legacy Firefox driver. #431

As you may know, Firefox, starting with Firefox 48, is not supported by built-in Selenium driver (let’s name it legacy driver). You must use new marionette/gecko driver, which also works with the older version of Firefox, but, it is not yet that stable in many cases. We experienced many projects with a large number of test switched to use Firefox 45 ESR, with the legacy driver, instead of the newest Firefox, because of high costs for analysis and changes for broken tests with the new driver. In 4.2 you may choose, which driver to use for Firefox version <=47

Use Configuration.browser="firefox" (or System property -Dselenide.browser=firefox) to use legacy Firefox Driver (Firefox<=47) built in Selenium.

Use Configuration.browser="gecko" or Configuration.browser="marionette" (the same) to use geckodriver (any Firefox version). If driver is not in your executable path, you may need to setup the path in SystemProperty webdriver.gecko.driver (for example -Dwebdriver.gecko.driver=/Users/mmeier/Downloads/geckodriver-0.11)

Microsoft Edge support

We added new value for browser - Configuration.browser="edge". Don’t forget to set the path to MicrosoftWebDriver.exe in SystemProperty webdriver.edge.driver

Better support for https site with invalid certificates.

In this version we turn on a capability, that helps to avoid error with invalid SSL certificates for many cases. You don’t need to change anything in your test, the improvement is automatically active.

Support of custom capabilities and cloud services (BrowserStack, SauceLabs etc.) #379

Until now, Selenide users did not have easy way to ask for custom capabilities for the browser. Starting from 4.2 System properties prefixed with capabilities.* automatically processed by Selenide as DesiredCapabilities. Among other things it helps to start your test by popular cloud service changing no line of your test code!

As example, let’s start you tests at BrowserStack (of course, you must register and get username & auth_key from the service first) under Windows 7 with Firefox 48 screen resolution 1680x1050. Just pass the parameters to your test runner:

-Dselenide.remote=https://<username>:<auth_key>@hub-cloud.browserstack.com/wd/hub
-Dcapabilities.os=windows
-Dcapabilities.os_version=7
-Dcapabilities.browser=firefox
-Dcapabilities.browser_version=48.0
-Dcapabilities.resolution=1680x1050

Please refer to the documentation of your cloud service about capabilities which should be set to get the desired environment.

Other changes

Fixed #433 bypass spawning local browser
Added method $.selectOptionContainingText(String) #391 - select option by substring.
Fixed problem with screenshot of too large WebElements #378

Upgrade to 4.2 today!

Alexei Vinogradov & Selenide Community

ru.selenide.org

Released Selenide 4.1

2016-12-01T00:00:00+00:00

Achievement unlocked!

This day came. We releases Selenide 4.1 that contain only your changes. Made by you. Your pull requests.

#428 Improve byAttribute method for search via css selectors

Method byAttribute (or shorter by) got more powerful. Before now, you could use it to find elements by attribute value:

$(by("first-name", "john macclane").click();

Now you can use it to search element by substring in attribute:

$(by("first-name*", "hn maccl").click();

by a starting of attribute:

$(by("first-name*", "joh").click();

by an ending of attribute:

$(by("first-name*", "clane").click();

and even by a word in attribute:

$(by("first-name*", "john").click();

Thanks to Roman Marinsky for pull request 428

#419 #425 Added methods `texts(List)` and `exactTexts(List)`

Before now, you could check texts in collection using varargs parameter:

$("#row-1 td").shouldHave(texts("pjotr", "iljich", "chajkovskij")));

Now you can also pass list instead of varargs:

List<String> expected = asList("pjotr", "iljich", "chajkovskij");
$("#row-1 td").shouldHave(texts(expected)));

Thanks to

Yakov Kramarenko for the suggestion, and
Pavel Smolensky for the pull request.

Improve support for gecko (marionette) driver

Now instead of

  new MarionetteDriver(capabilities);

Selenide initializes webdriver like this:

  DesiredCapabilities capabilities = createFirefoxCapabilities(proxy);
  capabilities.setCapability("marionette", true);
  return new FirefoxDriver(capabilities);

I still don’t understand if (and why) it’s better, but we are working on Marionette driver support anyway.

Upgraded dependencies:

selenium-java 3.0.1
htmlunit-driver 2.23.2
gson 2.8.0
guava 20.0
httpcore:4.4.5

News

Blogs post about Selenide in Japanese
Presentation about Selenide in Japanese
Selenide demo with Redmine and Docker

I cannot read Japanese, but look how beautiful those page objects are!

public class AdminPage extends AbstractPage {

    @FindBy(name = "commit")
    public SelenideElement デフォルト設定をロード;

    @FindBy(css = ".users")
    public SelenideElement ユーザー;
}

And more beauty in Japanese:

public void 添付ファイル数は(int size) {
  添付ファイル一覧.shouldHaveSize(size);
}

Isn’t it nice?

Selenide 4.2 will be released very soon.

Let’s upgrade!

Andrei Solntsev

selenide.org

Selenide presentation on TopConf 2016

2016-11-16T00:00:00+00:00

Good evening!

I recently presented Selenide on TopConf conference in Tallinn.

Video:

And my presentation:

Andrei Solntsev

selenide.org

A wrapper or pure Selenium?

2016-10-20T00:00:00+00:00

There is a popular opinion that using Selenide is not serious for a “true” automation engineer.
A real engineer should use pure Selenium to understand how it works inside.

And that’s why it’s bad.

A story of true driver

Imagine: you are in a great hurry to get on the plane. Get in a taxi, say: “Urgently to the airport!” And the taxi driver tells you: now I will put the motor on the frame, fasten the wheels, fill up the fuel - and we will go!

You freak out, but ok, since this is the accepted practice in this industry, then you have to wait.

Coverage

You wait five minutes, glancing nervously at your watch. You say: “Well, are we going already?” And you hear: “Yes, I have already screwed half the nuts in the motor.” And proudly adds: “I have 70% nut coverage!”

Reports

After another five minutes, you nervously ask again and hear: “Yes, yes, everything is cool! The seats are almost set.” And he proudly adds: “You can see the report with pictures of the steps taken.”

But if something should happen

You swear loudly and say, “What the hell? Why don’t we just get in the car and drive?”
And the driver says: “Let the junior engineers drive factory cars.
True drivers need to know how it works inside.”
And proudly adds: “But if something should happen, I can figure out what’s broken.”

Ready solutions

Needless to say, five minutes after the start of the movement, spark plug gets broken.
The driver says: “Yes, this is a typical problem. I know what to do. I’ve had it.
I am going to add a couple of sleep’s.”

Then the wheel falls off, and the dude with undisguised pride says that he faced this problem too, and he has a ready-made solution in his garage, which he stole from a previous project.

Yeah guys, this is the dude who prefers pure Selenium.

Sit and drive

Sooner or later, you give up and catch another car, in which everything is ready, configured and filled.
It just rides. And the driver just takes you to the airport. In time.

This is an engineer using Selenide.

So what, shouldn’t we learn Selenium?

I hope you find it funny at this place.
Probably some of you feel offended. And this is good! The more offensive the better.
The more likely it will make you wonder where our industry is heading.

When the resentment subsides, you should have a natural question.

So what, we should only use the ready-made solutions without learning their internals?
Shouldn’t a true driver know how the engine works and where to fill the oil?
Shouldn’t a true driver be able to fix a car if it suddenly breaks down in the middle of the road?

If everyone uses only ready tools, we will soon have no real specialists left!

My answer is:

Of course, learn!

Sure, we should learn. We must learn. It’s absolutely necessary.

A bad QA engineer is the one who does not dream of writing his own framework.

But not at the expense of the client!

Disassemble the engine. Dig into the pieces of iron. Play with solid oil. But - in your garage. In trainee garage.
But being at work - be so kind to do the work. Not your training.
When you have free time and energy, improve yourself.
When a client needs to go to the airport, take them to the airport and use the most effective tools for this.

That is Selenide, yes.

Andrei Solntsev

selenide.org

Released Selenide 4.0

2016-10-15T00:00:00+00:00

Hi all!

It happened, finally!

After 3-years-length waiting, Selenium WebDriver 3.0 was released.

And we released Selenide 4.0.

What changed?

Actually nothing should change for you. They just cleared some legacy garbage from selenium (that was never used by Selenide).

What is actually important that Selenide now requires Java 8.

Hurrra!!! Now QA world will finally move to Java 8 and lambdas!

Can I get more details!

Sure. Here is a list of Selenium WebDriver 3.0.0 changes.

News

About another major upgrade for unit-tests: Migration to Mockito 2.1
About old good things: Spring boobs
Great portal for developing your testing skills

Let’s upgrade!

Andrei Solntsev

selenide.org

Released Selenide 3.11

2016-10-14T00:00:00+00:00

Good evening!

We released Selenide 3.11! This is the last release in 3.x series. The last working on Java 7 and Selenium WebDriver 2.x

The following is Selenide 4.x: Selenium WebDriver 3.x and Java 8.

So, what we have in Selenide 3.11:

Added condition `checked`

Now you can write readable test for checkbox:

  $("#i-agree").shouldBe(checked);

Before now, you had to write $.shouldBe(selected) which is not pretty clear.

Checkbox should be checked.

See issue 416

Optimization of `getMessage()`

There is a strange behaviour in Selenium. When you get any exception from WebDriver (any subclass of SeleniumException), its method getMessage() is called.

And method SeleniumException.getMessage() tries to be too smart. It tries to add IP and host name of current machine to the error message. And detecting host name can be very slow.

And it appeared that Selenide does call this method multiple times.

I believe that getMessage() should not this. It’s not its business. But all we can do is just to optimize getMessage() calls, so that Selenide would not call this method multiple times.

So we did it.

See issue 415

Waiting for Selenium 3.0…

Andrei Solntsev

selenide.org

BDD with Selenide

2016-09-28T00:00:00+00:00

Hi!

People often ask if they can use BDD with Selenide.

Short answer: Yes, you can!

There is plenty of BDD tools in Java and Python. You can use any of them with Selenide. Some working examples: Selenide + Cucumber: https://github.com/selenide-examples/cucumber/tree/master/src/test/resources/org/selenide/examples/cucumber

Selenide + JBehave: https://gist.github.com/mp911de/009ea539271da0633c59

Selenide + GEB: https://github.com/selenide-examples/geb-maven-tutorial/blob/master/src/test/groovy/stepdefs/IndexStepDefs.groovy

Selenide + Gauge: https://github.com/selenide-examples/GaugeSelenideExample/blob/master/specs/example.spec You can find a whole book here full of examples with Selenide, JBehave and Cucumber: https://www.amazon.com/Test-Driven-Java-Development-Viktor-Farcic/dp/1783987421?tag=viglink12630-20

P.S. I personally don’t value BDD really much. I think it’s a nice idea, but it doesn’t really work. Business stakeholders do not really write executable specifications.

Let’s upgrade!

Andrei Solntsev

selenide.org

Released Selenide 3.10

2016-09-26T00:00:00+00:00

Hi!

We released Selenide 3.10!

Proxy server is disabled by default

It’s I am sad to say this, but it seems that the experiment with a proxy server has not yet succeeded.

There is a problem with the “new way” of downloading files using Selenide built-in proxy server. It works for all my projects, but some folks reported that it doesn’t work for them. I still don’t know exactly the problem and its causes. Probably those who use Selenium Grid experience this problem.

Anyway, now we reverted default downloading mechanism to HTTPGET. If you need to use proxy server, enable it via system property:

-Dselenide.fileDownload=PROXY

Or directly in your code:

Configuration.fileDownload = PROXY;

By the way, we fixed issue 393: Selenide will not even try to run proxy server until fileDownload=PROXY is set.

Added support for multiple selects

There are dropdown lists that allowing selecting multiple options (<select multiple>). Now it’s easy to select multiple options in Selenide with just one command:

select.selectOption("Margarita", "Theodor Woland");  // by test
select.selectOption(0, 2, 3);                        // by index
select.selectOptionByValue("cat", "woland");         // by value

We also added a method for getting all selected options:

select.getSelectedOptions().shouldHave(texts("Margarita", "Theodor Woland"));

See issue 400

Now you can print report only for failed tests

As you probably know, in Selenide you can print report of all executed steps .

Now you can configure if it should be printed only for failed tests. Or only for succeeded tests. Or always.

For JUnit:

   @Rule
   public TestRule report = new TextReport().onFailedTest(true).onSucceededTest(false);

For TestNG:

  @Listeners(TextReport.class)
  public class GoogleTestNGTest {
    @BeforeMethod
    public void setUp() {
      TextReport.onSucceededTest = false;
      TextReport.onFailedTest = true;
    }
  }

See. issue 408

Fixed bug with parsing http header `Content-Disposition` containing encoding

Now Selenide uses correct file name even if header Content-Disposition contains encoding:

Content-Disposition: filename=Prices.csv;charset=UTF-8

See. issue 398

Fixed bug 401: “Selenide swallows exception in some cases”

Never ever write catch (Throwable). Never!

See. issue 401

Method `open(url)` now works for URL in upper case

It’s weird, but sometimes people want to enter url in upper case. And they found that Selenide could not open such urls. Ups.

Now we fixed it: issue 407

Uncommented one old test

See. issue 379

News

Test mobile? Now it’s easy! Examples of Selenide+Appium

Yes, you can use Selenide for testing mobile applications!

Let’s upgrade!

Andrei Solntsev

selenide.org

Released Selenide 3.9.2

2016-09-03T00:00:00+00:00

Good evening!

We released Selenide 3.9.2!

You can download files differently

As you know, we changed a way of downloading files in Selenide 3.9. We got quite different feedback: some folks reported that new way works for cases where old way didn’t work, while others reported that the new way doesn’t work for cases where the old way worked.

That’s why we decided to provide users a choice.

Now you can choose how to download files.

“New” way - PROXY

This way is enabled by default.

It downloads files using selenide’s own embedded proxy server.

Pros:

This is better because it’s more universal: it not only works with <a href elements, but with any other elements too. Actually it doesn’t depend on web elements at all. It just intercepts all server responses containing files.

Cons:

If you run your own WebDriver instance (and add it to Selenide using method setWebDriver()), it knows nothing about selenide proxy server, which cannot intercept server responses. We will think how to improve this situation.

“Old” way - HTTPGET

If you need to use the “old” way, just add system property -Dselenide.fileDownload=HTTPGET. Or directly in the code:

Configuration.fileDownload = HTTPGET;

Pros:

It works independently from selenide proxy server.

Cons:

It works only with <a href elements, and can execute only GET requests.
It may not work if the machine that runs your tests doesn’t have access to a server from which files are downloaded.

Now you don’t have excuse not to upgrade to Selenide 3.9.2

Statistics update

Selenide download statistics for August 2016:

Andrei Solntsev

selenide.org

Released Selenide 3.9.1

2016-08-27T00:00:00+00:00

Hi all!

We released Selenide 3.9.1!

Killer feature! Selenide can now download any files. From anywhere.

We planned to do it for a long, and now it finally happened! Those endless problems with downloading files in Selenium are over. Now it’s easy. Just one simple method for all cases:

File report = $("input#submit").download();

Actually method download existed in Selenide for a long time. But it could only download files from links with href attribute: <a href.

It was good, but not enough in some cases. For example:

Button click submits a form - resulting in downloading a file
Button click opens a PDF in new tab (“inline” mode - browser built-in PDF viewer)

Now Selenide can download any files in all these cases. To make it possible, Selenide run a built-in proxy server (namely, BrowserMobProxy).

How downloading works:

Test executes command $("selector").download();
Selenide activate the proxy server
Selenide clicks the element
Proxy server catches all server responses that contain http header Content-Disposition. Selenide extracts file name from this header, and saves corresponding file to folder build/reports/tests.
Selenide waits (up to 4 seconds) until at least one file gets downloaded.
Method $.download() return the first downloaded file.
If some new tabs/windows has been opened meanwhile (during steps 1-6), Selenide will closes all of them. It’s needed for cases when PDF gets opened in a new tab.

See issue #196 and pull request #267.

Huge thanks to Dmitrii Demin for his commitment to this feature, suggestions and discussions!

Selenide proxy server

Yes, now Selenide runs its own proxy server when running tests.

In future we can use it for implementing other useful features. For example, we could check http statuses of pages and other resources. We could inject own code into pages etc.

Please share your ideas, let’s brainstorm!

Warning about too large requests/responses

Now Selenide tracks size of requests and responses. If some of them exceeded 2 MB, Selenide will write a warning in logs.

This is experimental feature. Please share your experience with it. Did you get new knowledge? Did you have some problems with it?

See issue #383

Now `SoftAsserts` listener works correctly with TestNG

We found that TestNG is a bad boy. Really, it has some really weird issues. For example, if you declare @Listeners(SoftAsserts.class) in some of your test classes, TestNG will automatically apply SoftAsserts listener to all of your tests. Unbelievable!

We created a workaround for this problem. Now SoftAsserts listener will check if the current test (or its parent) really declares annotation @Listeners(SoftAsserts.class).

See issue #384

Now `SoftAsserts` TestNG listener ignores tests with attribute “expectedExceptions”

Let me describe the problem. Suppose you have a test:

  @Listeners(SoftAsserts.class)
  public class MyTest {
    @Test
    public void myCheckA() {...}

    @Test(expectedExceptions = ...)
    public void myCheckB() {...}
  }

Obviously, SoftAsserts mode should be used in method myCheckA, but should not be used in method myCheckB. Because myCheckB expects some specific error, and SoftAsserts would break the whole flow if it caught the error.

See issue #372

Fixed bug with basic auth in IE browser

See issue #366 and pull request #369

Thanks to Anton Aftakhov for this pull request!

Upgraded to gson 2.7

Selenium uses quite old gson 2.3.1, but sometimes you want to use a newer one.

News

My interview on popular russian IT portal: About legacy code
Why programmer cannot be a good tester
Released video-recorder 1.0.8 - a really cool thing! Now production ready.

Let’s upgrade!

Andrei Solntsev

selenide.org

Released Selenide 3.8

2016-08-06T00:00:00+00:00

Good night!

We released Selenide 3.8! It fixes some small issues and introduces small but useful features.

Fixed file uploading on remote browsers in Grid

Thanks to Alexei Vinogradov for fixing remote upload!

Now you can disable automatic creating of *.html files

When your test fails, Selenide automatically saves 2 files:

Screenshot - *.png file
Page source code - *.html file

But sometimes people don’t want to save *.html files. For example, in case of single page application the page source contains html code of all application pages. Thus it’s too big and useless.

Now you can disable saving html files. As usually, via system property:

  mvn test -Dselenide.savePageSource=false

or directly in your code:

  Configuration.savePageSource = false;

Thanks to Boris Osipov for this pull request!

Added method `$.dragAndDropTo(WebElement)`

Until now, Selenide had only method $.dragAndDropTo(String), where string parameter is CSS selector of target element. But sometimes you want to define target element in another way.

Now you can use the new method $.dragAndDropTo(WebElement). For example:

  SelenideElement target = $(byText("Drop here"));
  $("#from").dragAndDropTo(target);

See issue #355

Now TestNG annotations `SimpleReport` and `SoftAsserts` are thread-safe

If you use annotations SimpleReport or SoftAsserts and TestNG framework, and run tests in parallel, you could see an empty report sometimes. Or you could get ConcurrentModificationException time-to-time.

It appeared that TestNG is bad boy. Just bad. If you declare @Listener(SoftAsserts) for one test class, TestNG creates a single instance of SoftAsserts and uses for ALL tests (even parallel).

As opposite, JUnit is cool guy. It creates a new instance of every test class and every Rule before running every next test method. Thus it avoids dependencies between tests and random failures because of previous tests.

We have fixed this problem. Now SoftAsserts listener can work in several parallel threads. Even in TestNG.

See issues #364 and #303.

Added new methods to class `Selectors`: `byCssSelector()` and `byClassName()`

I am still not sure that it’s really needed, but people asked for it many times. No Selectors has by* analogues for all selenium By.* methods.

See issue #360.

Fixed JavaScript error when running Edge browser

Now you can run your Selenide tests with the new Microsoft browser Edge. People say it should be quite fast.

See issue #339.

Now method `$.screenshot()` saves screenshots in a right place

Selenide has method for saving screenshot of a single element (not a whole page):

  String screenshotFile = $("#footer").screenshot();

The problem is that this method saved screenshot to the project root. Now it’s fixed, and saves screenshot to the right place - build/reports by default.

See issue #290.

Added protection against invalid soft asserts usages

Now Selenide will throw an exception if you enable “Soft asserts” mode, but forget to add SoftAssert annotation to your test classes.

See issue #302.

We added link to implementation to all `SelenideElement` methods’ javadoc

For example, method $(“input”).setValue(“hello”) is actually implemented in class SetValue

See issue #367.

Upgraded to htmlunit 2.23

See htmlunit release notes

News

Article about Selenide in Spanish by Dario Lamy
Why developers must be good testers
New cool conference in Saint-Petersburg: Heisenbug - looks promising, I am going to speak there
New cool article from Uncle Bob: The Churn
What is a true hardcode
True page objects

For dessert

And for dessert - a fresh joke about Chuck Norris:

Chuck Norris does not use Selenide.
Chuck Norris writes tests in pure Selenium webdriver.
Chuck Norris is immortal - he has enough time for this.

Let’s upgrade!

Andrei Solntsev

selenide.org

Released Selenide 3.7

2016-07-08T00:00:00+00:00

Hi all!

We released Selenide 3.7!

Upgraded to Selenium 2.53.1

It should fix the problem with Firefox 47.

Added support for Marionette browser

To run your tests with Marionette browser, you can set parameter in command line (or build script):

-Dselenide.browser=marionette

or set browser directly in your tests:

  Configuration.browser = "marionette";

see. pull request #349

Thanks to Geroen Dierckx for this pull request!

Added support for non-web drivers

There are some “webdrivers” that do not actually drive web-browsers, but

native Windows applications (Winium),
Java Swing applications (Marathon),
and even mobile applications (Appium).

Naturally, these drivers do not support JavaScript. It appeared that Selenide could not work without JavaScript.

In Selenide 3.7, we have fixed this problem. Now Selenide should work with non-web drivers.

see. issue #345

Removed useless message `Screenshots:` if screenshots are disabled

see. pull request #357

Thanks to Boris Osipov for this pull request!

Statistics update

Selenide download statistics for June 2016:

And unique IPs statistics:

It’s still growing!

Andrei Solntsev

selenide.org

We released Selenide 3.6

2016-06-01T00:00:00+00:00

Good day!

In the last day of spring, we released Selenide 3.6.

Reverted page loading strategy to `normal`

In Selenide 3.5 we set default page loading strategy to none. It made tests faster for some users, but other users complained that it broke their tests, so that they had to rollback to Selenide 3.4.

Now the default page loading strategy is again normal (it’s Selenium default). If you want to speed up your tests, just configure

-Dselenide.page-load-strategy=none

Configuration.pageLoadStrategy = "none";

See issue #321

Now page objects don’t have to be public

… or have public constructor.

public class GoogleSearchTest {
    private SearchPage search;

    private static class SearchPage {
      public ResultsPage searchFor(String keyword) {
        $(By.name("q")).val(keyword).pressEnter();
        return page(ResultsPage.class);
      }
    }
}

Make it private. Remove useless constructors. Clean up your code.

See issue #335

Added support for JBrowser webdriver

JBrowser is a new headless browser (like HtmlUnit and PhantomJS). In theory, it could be faster than usual browsers. In practice, JBrowser seems to be unusable yet: most of Selenide own tests fail with it.

But you can try it by yourself: -Dselenide.browser="jbrowser".

And you will need to add dependency to your project:

<dependency org="com.machinepublishers" name="jbrowserdriver" rev="[0.13.0, 2.0)" conf="test-default"/>

See issue #329

Thanks to Anil Kumar Reddy Gaddam for this pull request!

Method $().download() now uses the standard selenide timeout

Before this change, method $.download() could hang sometimes. Now it works no longer that 4 seconds (or whatever timeout you configured).

See issue #341

Added support for Basic Auth for all common browsers

You can find usage examples here:

Selenide.open("http://httpbin.org/basic-auth/user/passwd",
        "",
        "user",
        "passwd");

See issue #320

Thanks to dimand58 for this pull request!

Added method `$.screenshotAsImage()`

It allows to get an image of some element. It may be useful for debugging, especially when the page is large, and all elements do not fit on the screen.

BufferedImage elementScreenshot = $(".logo").screenshotAsImage();

Thanks to Akkuzin for this pull request!

Fixed TestNG TextReport Listener

now the report will only be generated for classes annotated with @Report.

If I understand correctly, it is a TestNG: if listener is declared in one of test classes, it’s applied to all tests. Like this:

@Listeners(TextReport.class)

It may be a problem if you want to generate a report only for some problematic tests.

Now we fixed it. The report will not be generated for all test classes, but only those annotated with @Report.

Thanks to Alexei Vinogradov for his work on TestNG listeners!

Upgraded phantomjsdriver to version 1.3.0 (compatible with selenium-java 2.53.0)

Unfortunately, PhantomJS Driver project has been asleep for a while. Its original author Ivan Marino declared that he cannot support the project anymore. :(

That’s why we forked it and released phantomjsdriver 1.3.0, that is compatible with the latest Selenium Webdriver 2.53.0. And now this version is included with Selenide 3.6+.

That’s all about Selenide 3.6.

Download and test with pleasure!

Other news

It’s not a fantastic, it’s real: How to use Selenide in C# .NET / Oleg Volodin
One more article about Selenide in Japan / tatesuke
Tutorial: Selenium Tests with Maven and Selenide / Konstantin Pavlov

Statistics

This is Selenide download statistics for May 2016:

The Army of Seleniders is growing!

And what’s up with you?

Andrei Solntsev

selenide.org

Released Selenide 3.5

2016-03-31T00:00:00+00:00

Hi all!

We released Selenide 3.5 with flexible collection size checks.

We added flexible checks for collection size

Before now, we could only check the exact size of collection:

  $$(".man.angry").shouldHave(size(12));

Now we can use flexible checks: <, <=, >, >=, <>

Simple like this:

  $$(".man.angry").shouldHave(sizeLessThan(13));
  $$(".man.angry").shouldHave(sizeLessThanOrEqual(12));
  $$(".man.angry").shouldHave(sizeGreaterThan(11));
  $$(".man.angry").shouldHave(sizeGreaterThanOrEqual(12));
  $$(".man.angry").shouldHave(sizeNotEqual(42));

Thanks to vasilevichra for this pull request!

P.S. Actually I am still not sure that this is a good idea. I think that test must prepare required preconditions before running application. It means that test must always know exactly how many elements should be on the page at every moment. But we implemented it because users kindly asked for it.

Speed up of page loading

By default Selenium webdriver waits until all elements of a page (html, script, style, img) are completely loaded. It may be slow, for example, if there are big images on the page. And it’s not really needed, especially in case of Selenide that can wait for any expected conditions.

That’s why we used page loading strategy none in Selenide 3.5. It should make your tests faster.

Of course, you still can use any other strategy if you need.

Either by system property:

-Dselenide.page-load-strategy=normal

Or directly in code:

Configuration.pageLoadStrategy=eager;

You can find all available strategies here.

Fixed method toString()

Selenide can print detailed information of web elements. When you write System.out.println($("option#abc")), you will see a text and all attributes of this element:

<option id="abc" value="livemail.ru" selected:true>@livemail.ru</option>

It’s really cool feature, and by the way, Selenium cannot do it.

That’s why we had to use dirty JavaScript hacks to print all the attributes.

But we found that this method prints only the initial value of attribute value, even if it has been modified dynamically. We fixed this problem in Selenide 3.5. Now method toString() always prints out the actual value of value.

Upgraded to selenium-java 2.53.0

Here is selenium 2.53.0 changelog.

News

The historical moment: Selenide has been mentioned in Wikipedia
Yakiv Kramarenko presentation on SeleniumCamp 2016 conference: Selenide Alternative in Practice
Selenide receipts: Appium + Selenide
Post about automation system of the printing company Ardecs Print Activity: Selenide simply offers not to bother
Article about Selenide in Software testing magazine
Article about Selenide from Fabricio Galdino: API Selenide: Developing Functional Tests in Java

Statistics

The following is statistics of Selenide downloads in February 2016:

And number of unique IP:

The army of Seleniders is growing!

We plan next Selenide release pretty soon. We are going to include proxy server BrowserMobProxy in it, so that Selenide could download files and use other powerful magic.

And what’s up with you?

Andrei Solntsev

selenide.org

Released Selenide 3.3

2016-02-11T00:00:00+00:00

Good evening!

We released Selenide 3.3 with support for collections.

Ajax support for collections

Now collection methods $$ can wait until collection elements get loaded. It can be useful for collections that are loaded asynchronously with Ajax.

See. issue #277

Added separate timeout for collections

We added two configuration parameters:

collectionsTimeout (default value 6 seconds)
collectionsPollingInterval (default value 0.2 seconds)

Typically collections are loaded longer than single elements (they contain more than one element). That’s why they need longer timeout.

Upgraded to selenium-java 2.51.0

See selenium 2.51.0 changelog.

News

Java Advent calendar: Effective UI tests with Selenide
Post about Selenide on KOREAN.
Post about Selenide on Portugal.
Selenide cheat sheet
Selenide receipts

Let’s communicate!

Now we have new possibilities to discuss new features and old problems of Selenide. You are welcome!

And what’s up with you?

Andrei Solntsev

selenide.org

Released Selenide 3.2

2016-01-29T00:00:00+00:00

Good morning!

We released Selenide 3.2

Now Selenide logs browser version

We added INFO log containing version of browser, Selenium and Selenide:

32:45 INFO BrowserName=chrome Version=48.0.2564.109 Platform=MAC
32:45 INFO Selenide v. 3.2
32:45 INFO Selenium WebDriver v. 2.51.0 build time: 2016-02-05 11:20:57

Better report

We renamed FAILED->FAIL, PASSED->PASS in selenide report. So they don’t mess with PASSED and FAILED that are typically written by Maven and other tools. Now it’s a little bit easier to analyze Selenide output in Jenkins.

Added method for selecting option by index

Before Selenide 3.2 you could select an option by text or value:

    $("select#email").selectOption("@gmail.com");
    $("select#email").selectOptionByValue("98347643");

Now you can also select option by index:

    $("select#email").selectOption(4);

Added setting `selenide.browser-size`

Now you can set browser size before running tests:

java -Dselenide.browser-size=1024x768

or directly in code:

@Before
public void setUp() {
  Configuration.browser = "chrome";
  Configuration.browserSize = "1024x768";
}

It’s probably a good idea to declare a (minimal) expected browser size supported by the application in test. So your tests will verify that the application works on that small displays.

Upgraded to selenium-java 2.50.0

See selenium 2.50.0 changelog.

See you later! Selenide 3.3 is coming soon!

Andrei Solntsev

selenide.org

Released Selenide 3.1

2016-01-17T00:00:00+00:00

Good evening!

Good new year news: we released Selenide 3.1.

Updated documentation

We fixed and updated documentation on site.

Thanks to Aleksei Vinogradov and Erik Khalimov for hard work!

Method `$().download()` does not allow invisible links

Before Selenide 3.1, method $().download() allowed to download files from invisible links. We fixed this bug. Thanks to @dimand58 for this pull request.

Methods `switchTo(...)` now can wait if needed

Methods switchTo(alert()), switchTo(frame()), switchTo(window()) got smarter. Now they can wait a little bit, if alert, frame or window is not loaded yet. As usually, default timeout is 4 seconds.

Added methods `byName`, `byXpath`, `byLinkText`, `byPartialLinkText`, `byId`

These are new static methods in class Selectors (where methods byText and withText were). Actually they are just aliases for selenium built-in By.* methods. I am not sure they are really useful, but some folks like the idea of not using any Selenium classes in their tests. Also it was needed for folks who use Selenide in their .NET tests. Imagine, people!

Condition`$.shouldHave(exactTextCaseSensitive("..."))` checks the entire string

Before Selenide 3.1 it checks only a substring. We fixed this bug.

Methods `$(WebElement, selector)` and `$$(WebElement, selector)` marked as deprecated

It’s recommended to use method find instead:

$(WebElement).find(selector)
$$(WebElement).find(selector)

Added method `$.getValue()`

Actually this is just an alias for $.val().

Selenide includes phantomjsdriver 1.2.1 out of the box

Now you don’t need to include additional dependencies to use PhantomJS in your tests.

Upgraded to selenium-java 2.49.0

See selenium 2.49.0 changelog.

See you! Selenide 3.2 and 3.3 is coming soon!

Andrei Solntsev

selenide.org

Released Selenide 3.0

2015-11-30T00:00:00+00:00

Hello!

We released Selenide 3.0. Finally!

NB! Selenide 3.0 is a major upgrade, meaning that something can become broken.

Don’t be afraid: if you used only public API and didn’t used @Deprecated methods, then nothing changes for you. But if you did, read carefully.

Historical notes

The first version Selenide 1.0 was created in year 2011. We silently tested and tuned it for more than a year.

In March 2013 we went to SeleniumCamp conference in Kiev and released Selenide 2.0 there. In 2.0 we cleaned up all the legacy and left only the new API. Then was the first “public” version of Selenide 2.0 born. At that moment, SelenideElement has only a dozen of methods and was called ShouldableWebElement. :)

Since that we released 25 versions Selenide, it got a lot of new functions, and its own legacy @Deprecated methods. We needed changes.

That’s why we finally released Selenide 3.0

New functions in Selenide 3.0

There is only one new function - method Selenide.updateHash(). It’s useful for testing rich ajax applications that react to “#” changes in URL. Method updateHash() changes “#bla-bla” part of current URL without reloading the page.

Look here for usage example.

Thanks to @fabienbancharel for pull request #254

Upgraded dependencies

upgraded to Sizzle 2.2.1
upgraded to Guava 19.0
upgraded to TestNG 6.9.10

It only affects you if you use some of these libraries.

Big refactoring

We refactored class AbstractSelenideElement. Now, instead of one huge class, we have a lot of small classes (in package com.codeborne.com.commands). Everyone of them has its own responsibility.
You can easily override any of SelenideElement methods.
You can even add your own methods to standard Selenide and Selenium methods.

We will describe these great options in details in a separate post, but you can look to examples in Selenide tests.

Thanks to Iakiv Kramarenko for his ideas and night discussions.

Big cleanup

Like we announce earlier, we cleaned up all the old stuff.

Remove deprecated conditions:
- notPresent -> Use method $.shouldNot(exist) or $.shouldNotBe(present).
- hasOptions -> Not needed anymore. Use methods $.selectOption() or $.selectOptionByValue().
- options -> Not needed anymore. Use methods $.selectOption() or $.selectOptionByValue().
- hasNotClass -> Use method $.shouldNotHave(cssClass("abc"))
Remove deprecated class JQuery
Remove deprecated class PrettyReportCreator (use class TextReport for JUnit or TestNG)
Remove deprecated methods
- Selenide.switchToWindow(title) -> use method switchTo().window(title)
- Selenide.switchToWindow(index) -> use method switchTo().window(index)
Remove deprecated methods
- WebDriverRunner.ie() -> use method WebDriverRunner.isIE()
- WebDriverRunner.htmlUnit() -> use method WebDriverRunner.isHtmlUnit()
- WebDriverRunner.phantomjs() -> use method WebDriverRunner.isPhantomjs()
- WebDriverRunner.takeScreenShot() -> use method Screenshots.takeScreenShot()
Remove deprecated methods
- $.should*(String message, Condition condition) -> use method $.should*(condition.because(message))
Remove class com.codeborne.selenide.impl.Quotes because it was migrated to Selenium Webdriver (org.openqa.selenium.support.ui.Quotes)

Feel free to give feedback if you get something broken.

News

Selenide got to Best tools and sites for Java in 2015
Article about Selenide in Java Advent Calendar 2015 Effective UI tests with Selenide
Article about Selenide in Japan Selenide Java Library：簡単なことは簡単に，Web UI テスト自動化の敷居を下げ，生産性をあげる魔法の Wrapper

Happy new year!

I wish you fast and effective tests.

Andrei Solntsev

selenide.org

Changes in Selenide 2.25

2015-11-30T00:00:00+00:00

Good evening!

Today we released Selenide 2.25. It’s the last Selenide version in 2.* line. A big refactoring, clean-up of deprecated stuff and Selenide 3.0 follows soon.

Please review your tests and be sure you don’t use any @Deprecated methods. We are going to remove them in Selenide 3.0.

But now - Selenide 2.25 highlights:

We added “Selenide profiler” for TestNG

You probably know that Selenide suggests a profiler for your tests named PrettyReportCreator. It was only available for JUnit until now. Now we created the same profiler for TestNG.

By the way, we renamed it to TextReport.

To use profiler with JUnit:

  @Rule
  public TestRule report = new TextReport();

To use profiler with TestNG:

  @Listeners(TextReport.class)
  public class GoogleTestNGTest {
    ...
  }

We added methods `$$.first()` and `$$.last()`

Now it’s easy to get the first and the last elements of a collection:

  $$("#employees .fired").first().shouldHave(text("Steve Jobs"));
  $$("#employees .fired").last().shouldHave(text("Richard Williamson"));

We added method `Screenshots.getLastScreenshot()`

It returns the last screenshot taken by Selenide. It’s can be useful for those who wants to integrate Selenide with reporting frameworks like Allure.

By the way, we renamed method getScreenShotAsFile() to takeScreenShotAsFile(), because the former name was wrong: this method does take a screenshot, not only returns a screenshot.

We added methods Selenide.confirm() and Selenide.dismiss()

For handling modal dialogs, Selenide had methods confirm(String) and dismiss(String) with parameter - expected dialog text.

  confirm("Are you sure you want to remove file?");
  dismiss("Are you sure you want to remove file?");

These methods click “ok” or “cancel” in a modal dialog “confirm” and check the dialog’s text.

But sometimes you don’t need to check the text. That’s why we added parameterless methods confirm() and dismiss():

  String text = confirm();
  String text = dismiss();

these methods do not check, but return dialog text.

We added option `-Dselenide.reopenBrowserOnFail`

By default Selenide tries to re-open browser if it died. It seems to be a good idea: one test fails, but the following tests will continue running.

But sometimes you want to avoid re-opening the browser and let all other tests fail.

In this case just use the new option: -Dselenide.reopenBrowserOnFail=false

Upgraded to htmlunit 2.19

Some folks think that HtmlUnit is died, but we still like it. At least tests of Selenide itself run stably on HtmlUnit.

Changed Selenide license MIT

We wrote about license in a separate post, but shortly said - MIT license is the most permissive. We hope that some bureaucratic companies who are afraid of “GPL” characters can now start using Selenide.

News

Selenide presentation on Devoxx 2015 - the biggest Java conference in Europe

And what’s up with you?

Andrei Solntsev

selenide.org

Selenide changes license to MIT

2015-11-16T00:00:00+00:00

Good evening!

We decided to change Selenide license from LGPL to MIT.

Shortly said, it means that you can do with Selenide whatever.

MIT is the most permissive license.

Here you can find illustration for differences between most common open-source licenses MIT, Apache and GPL.

Why not LGPL?

Actually we like LGPL. LGPL means that you must publish your code as open-source only if you include Selenide code into your product. But you use Selenide in tests, so you don’t include Selenide into code that is delivered to your customers. That’s why you don’t need to publish your source code.

Why we changed the license?

It seems that many companies are just afraid of GPL. They just don’t want to have any business with GPL, without diving into details. That’s why we decided to switch Selenide license to the most permissive - MIT license.

If you have any friends that didn’t use Selenide because of license - now you have good news for them! :)

Andrei Solntsev

selenide.org

Selenide presentation on Devoxx 2015

2015-11-13T00:00:00+00:00

Now in Europe!

I have presented Selenide on Devoxx - the biggest Java conference in Europe.

Here is video of my talk:

And slides:

Here you can find other Devoxx 2015 videos.

Andrei Solntsev

selenide.org

Changes in Selenide 2.24

2015-11-08T00:00:00+00:00

Good morning! We released Selenide 2.24. It’s a minor release.

Upgraded to selenium-java 2.48.2

changelog of selenium 2.48.2.

Add method `$.pressEscape()`

In addition to methods

$("input").pressEnter();
$("input").pressTab();

we have now new method:

$("input").pressEscape();

Fixed soft asserts for TestNG

As you probably know Selenide has soft asserts functionality. Some time ago it was broken if you run tests in TestNG. Now we fixed it.

Logic of webdriver creation extracted to a separate class WebDriverFactory

Before this release, class WebDriverRunner created browsers. But it grew to be too large: it also detects hanging browsers, closes and reopens browsers etc. That’s why we extracted logic of creating webdrivers to a separate class.

News

Conference Devoxx.be
I will present Selenide at the largest European Java conference Devoxx in Antwerp
That’s great!

And what’s up with you?

Andrei Solntsev

selenide.org

Introduction to Selenide on SeleniumConf 2015

2015-09-23T00:00:00+00:00

Finally!

I have got a change to introduce Selenide on SeleniumConf conference that took place in Portland this year.

Here is video of my talk:

And slides:

Here you can find other SeleniumConf videos.

Andrei Solntsev

selenide.org

Changes in Selenide 2.23

2015-09-15T00:00:00+00:00

Hi all!

In september we released Selenide 2.23. Let’s take a look on news.

New method `$.selectRadio()`

In order to select radio button, Selenide had a method

Selenide.selectRadio(By.name("gender"), "male");

Now we have new method that is more consistent with other Selenide methods:

$(By.name("gender")).selectRadio("male");

As other Selenide methods, it can wait if the radio button is not available yet.

Method `$.setValue()` can now handle radio buttons

We try to make Selenide as universal as possible, so that you would not need to think about low-level technical details of web elements. For instance, method $.setValue() detects what type of web element you are operating with: input, select or textarea - and behaves correspondingly.

Now it also supports radio buttons.

Method $.setValue() can now select radio buttons too:

$(By.name("gender")).setValue("male");
$(By.name("gender")).val("male");

You cannot set value to readonly field

Now method $.setValue() will throw an exception if you try to set value into readonly field.

Be aware, it probably can break your tests.

Method `$.setValue()` takes attribute `maxlength` into account

If you try to enter too long text to input field having attribute maxlength, Selenide will cut the text.

Be aware, it also can break your tests.

Fixed issue with unclosed FireFox instances

Some users reported problems with Firefox browsers that left unclosed after running Selenide tests.

Unfortunately we could not reproduce the problem, so that we just had to roll back the old good mechanism of running browsers. We will continue work on new mechanism with timeouts check.

News

Let me share some great news with you.

Conference SeleniumConf 2015

Finally!
Selenide was presented at the annual SeleniumConf conference that was held this time in Portland, USA.
Here is video and slides of my talk.

By the way, other SeleniumConf 2015 videos are available here.
Historical moment: a book about Selenide has been published! Actually title of book is Test-Driven Java Development, but it contains code samples in Selenide with JBehave and Cucumber.
It’s just unbelievable, but this is true!

Selenide was also presented at Socrates conference at Germany: Ext JS 5 Tests with Selenide

Statistics

The following is statistics of Selenide downloads in August:

There will come much more in September!

And what’s up with you?

Andrei Solntsev

selenide.org

Changes in Selenide 2.21 and 2.22

2015-08-29T00:00:00+00:00

Good saturday!

Recently we released Selenide 2.21 and 2.22. They contain few but important changes.

Upgrade to Java 7

Starting from version 2.21, Selenide only works on Java 7 and higher.

If you used Java 6, it’s time to upgrade.

Upgrade to Selenium 2.47.1

It requires Java 7.
It supports native events only for FireFox 31. For later FireFox versions only synthetic events are supported.
It adds experimental support for the new browser “Microsoft Edge”.

All changes in Selenium 2.47.1

Fixed problem with unclosed browsers

In Selenide 2.20 we reworked mechanism of closing browser. But it caused a defect: sometimes browser left open. Now this problem is fixed.

Thank you for your help!

Thanks for all who voted for my proposal. It was accepted to the SeleniumConf 2015 conference. I am going 8.09 to Portland to present Selenide at the world’s biggest Selenium conference.

And what’s up to you?

Andrei Solntsev

selenide.org

Changes in Selenide 2.20

2015-07-27T00:00:00+00:00

Hi all!

We have released Selenide 2.20. Let me tell you what’s new there.

Protection against webdriver hanging

Sometimes we experience problems with webdriver: it hangs when trying to open or close browser. This thread just remains endlessly in the same state: “Forwarding newSession on session null to remote”. I guess it’s a bug in webdriver.

We added protection against this problem in Selenide 2.20.

Now Selenide runs opening/closing browser in a separate thread and limits its time. By default opening browser cannot take more than 15 seconds, and closing browser cannot take more than 5 seconds. In case of failure, Selenide re-tries (up to 3 times) and only then throws an exception.

Thank you @admizh for this suggestion!

See Issue 199 and Issue 204

Selenide now uses java.util.logging for logging

Up to now, Selenide used System.out and System.err for printing its messages.

Actually I think that this is good enough for testing. It’s simple and reliable.

But people often use different libraries/frameworks, and want to use common logging mechanism across all tests. That’s why we migrated Selenide to use “standard” mechanism java.util.logging (JUL).

To be honest, I don’t like jul. I think that log4j or slf4j is much better. But Selenium already uses JUL, so it seemed reasonable to use JUL also in Selenide instead of adding new dependencies.

Good news is that you don’t need to do anything to use the new logging. It works automatically. It prints logs to standard system output (aka console) by default. But it’s not beautiful:

Jul 25, 2015 10:48:21 PM com.codeborne.selenide.impl.WebDriverThreadLocalContainer createDriver
INFO: Create webdriver: 1 -> FirefoxDriver: firefox on MAC (3e54e3de-b212-2a45-93ad-712aae6ee853)

To make it more readable (if you haven’t yet configured JUL in your project), you can add the following line in the beginning of your tests:

System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tT %4$s %5$s%6$s%n");

If you prefer slf4j, just add dependency org.slf4j:jul-to-slf4j:1.7.12 to your project and these lines in the beginning of your tests:

SLF4JBridgeHandler.removeHandlersForRootLogger();
SLF4JBridgeHandler.install();

Now Selenide logs will look better:

22:48:15 INFO  INFO: Create webdriver: 1 -> FirefoxDriver: firefox on MAC (3e54e3de-b212-2a45-93ad-712aae6ee853)

See Issue 195

Fixed Cookies usage when downloading file

Thank you @philipp-kolesnikov for this pull request!

Added support for element collections to Page Objects

Now you can declare an elements collection in your page object:

public class SearchResultsPage {
  @FindBy(css = "#ires li.g")
  private ElementsCollection results;

See Issue 186

Thank you @rishaselfing for the suggestion!

P.S. Let me remind that it’s probably simpler to write page objects without annotations:

public class SearchResultsPage {
  private ElementsCollection results = $$("#ires li.g");

Method $(“select”).shouldHave(text(“…”)) now checks the selected option

Up to now, the $("select").shouldHave(text("...")) check was quite useless, because it checked texts of all <option> elements, not only selected ones. Now it checks only texts of selected option(s).

And method $("select").getText() returns only texts of selected option(s).

See Issue 134

Added method for taking screenshot of one element or region

Sometimes screenshots appear to be useless. When page is too big, the required element does not always fit to the screenshot. In this case you can find useful the new function for taking screenshot of one element.

It’s so easy to use:

    File screenshot = $("#some-div").screenshot();

See Issue 66

All methods `$(String, ...)` made deprecated

Please be sure that you don’t use deprecated methods. We are going to remove then in one of next Selenide versions (probably in Selenide 3.0).

Now there is a better way to add explanation to your checks using because function:

$("h1").shouldHave(text("Some wrong test").because("it's wrong text"));
$("h1").waitUntil(hidden.because("it's sensitive information"), 100);

Removed cglib-nodep from Selenide dependencies

We found what cglib-nodep dependency is too old and useless. And it can sometimes conflict with other project dependencies. It seems that it doesn’t support Java 8 and haven’t been updated for 5 years.

So we removed cglib-nodep from Selenide dependencies.

If you still need cglib-nodep for some reason, just add dependency cglib:cglib-nodep:jar:3.1 to your project.

I need your help!

Please vote for my submission to SeleniumConf 2015 conference here!

And what’s up with you?

Andrei Solntsev

selenide.org

Changes in Selenide 2.19

2015-06-21T00:00:00+00:00

Hi everybody!

We have released Selenide 2.19.

Several problems have been fixed, primarily with inner frames and self-signed certificates.

Working with inner frames

One of the most problematic objects for automated testing is frames.

Selenium Webdriver can switch to frame. But there are also inner frames in the field! Webdriver cannot switch into inner frame. Poor testers need to switch to parent frame, then to child frame, then to grandchild frame, etc.

In Selenide 2.19 we added a convenient method for switching directly into inner frame. Just as simple:

  import static com.codeborne.selenide.Selenide.*;
  
  switchTo().innerFrame("parentFrame", "childFrame_2", "childFrame_2_1");

By the way, searching of frame also works faster than in Selenium because of optimized locators usage.

Thanks to @dimand58 for this pull request!

PhantomJS can now work with self-signed certificates

Another problematic aspect for automation are self-signed certificates.

This is when your administrators desire security. They run your web application for testing on https (like https://test.company.ru). But they do not have enough money to use real trusted SSL certificated. And they use self-signed (aka untrusted) certificates on test-servers (that are typically available only in intranet).

As a result, we do not get any better security, but get infinite problems like “browser shows warnings”, “my script cannot download files”, “script cannot open application in IE” etc.

Webdriver providers try to make our life even more complex. There is standard webdriver setting "acceptSslCerts", which is understood by Chrome, FireFox and even htmlunit. But not PhantomJS. PhantomJS doesn’t understand this setting, it wants you to configure its own specific setting! And finally, IE doesn’t understand any settings.

We have done it. We configured the right settings, and now PhantomJS+Selenide can open your “https://test.company.ru”.

But IE still doesn’t work with self-signed https. Feel free to share your knowledge if you know how to cure it.

Method `$.download()` now supports self-signed certs

In case you didn’t know, Selenide has a very convenient method for file downloading:

File cv = $("#cv").download();

Now it also works when you try to download file from your mega-secure untrusted “https://test.company.ru”.

Method `$.setValue()` also triggers “focus” event

Before this, method $.setValue() (in fastSetValue=true mode) triggered events “keydown”, “keypress”, “input”, “keyup”, “change”. Now it also triggers “focus”. I am not actually sure that it’s really needed, added just in case.

Fixed bug with screenshots in Selenide 2.18

Selenide 2.18 introduced one bug: it took too many of screenshots. Even if tests didn’t failed. It didn’t cause test failure, but took more disk space. Now it’s fixed.

Upgraded to Selenium Webdriver 2.46.0

Changelog of 2.46.0 is quite impressive.

Added beta-version of Marionette webdriver (Firefox webdriver reincarnation?)
In some cases, selenium server should start 10x times faster
Native events not supported anymore in Firefox 33+
Presto-based Opera not supported anymore
Etc.

And what’s up with you?

Changes in Selenide 2.18

2015-05-06T00:00:00+00:00

Good evening!

In the end of April we released long-waited Selenide 2.18. It was hard. We have totally rewritten waiting algorithm, so now it catches all the StaleElementException.

Let me describe it in details.

Waiting algorithm

Selenide always fought against StaleElementException and other problems caused by Ajax and timeouts. But it was still possible to get StaleElementException in rare cases.

In Selenide 2.18 we reworked waiting mechanism.

The old algorithm was the following:

waitForElement().click()

Selenide waited until the element got visible, and only then performed required action (click in this example). In other words, the action was “two-phased”. And sometimes (especially in SPA applications) it could happen that the first phase has completed correctly (element was visible at that moment), but during the second phase (click in this example) element disappeared.

The new algorithm is the following:

  while (errors and <4 seconds) {
    element.click()
  }

This algorithm is faster, because it performs only one action for most elements (that do not disappear either appear). And probability of StaleElementException is much less (though, still non zero :().

Screenshots

Now Selenide takes screenshot after any failure. In previous versions, Selenide did not take screenshots, say, in case of selenium errors (e.g. method click() failed because element was not clickable).

Method `$.shouldHave(value("john"))` now ignores invisible characters (spaces, tabs, newlines).

It’s useful e.g. because numbers can be formatted with spaces or non-breakable spaces. Visually there is not difference. And user cannot see any difference. So, test must not too.

If you still need to verify exact value of element, you can use a special check: $.shouldHave(exactValue(" john ")).

Clicking with JavaScript

Now we have added a special “clicking mode”, in which click is performed with JavaScript (instead of default “native” browser click).

They say, it can be useful for running tests in IE, because IE doesn’t always properly click elements.

You can enable the new mode with property: -Dselenide.click-via-js=true

Thanks to @dimand58 for this pull request!

Added method `$.doubleClick()`

Like this:

  $(".modal-popup").doubleClick();`

Methods `$.hover()`, `$.contextClick()`, `$.dragAndDropTo()` now can be chained

It means, you can use them in one line:

  $("#username").hover().contextClick().doubleClick();

Fixed Sizzle selectors on pages without jQuery

Thanks to @Gert for this pull request!

Added method `WebDriverRunner.hasWebDriverStarted()`

It can be useful, say, when you want to take screenshots or perform some other custom actions with webdriver in your tests.

Thanks to @dimand58 for this pull request!

Method `$.setValue()` in `fastSetValue` mode now triggers `input` event

Now $.setValue() in fastSetValue mode triggers the following events:

keydown
keypress
input
keyup
change

It fixed autocompletion in some applications, and also filling of textarea. I hope that now $.sendKeys() can be totally replaced by fast method $.setaValue().

Could you do that?

Now Selenide depends on latest version of commons-codec 1.10

Previously Selenide downloaded (transitively from selenium-java) an old version of commons-codec 1.6 It could create problems for applications that wanted to use latest commons-codec.

Let me brag

Finally is the desert: fresh download statistics from maven central repository.

There is becoming more of us!

Number of unique IP:

And number of downloads:

And what’s up with you?

Changes in Selenide 2.16 and 2.17

2015-05-05T00:00:00+00:00

Hi Seleniders!

We haven’t written to blog for a while. There have been released 3 new versions of Selenide during this period.

Let me describe changes in versions 2.16 and 2.17

Soft asserts

We finally added SoftAsserts to Selenide. I am still not sure that it’s a good idea, but it was asked a lot. :)

In SoftAssert mode your tests do not fail immediately, but all the checks like $.shouldHave(text("xxx")) will collect errors and report all them at once in the end of test. It allows you to collect all the fails, fix them all and re-run test only once. It could be useful if cost of running tests is too big for you.

To enable Soft asserts in JUnit (see documentation):

public class SoftAssertJUnitTest {
  @Rule public SoftAsserts softAsserts = new SoftAsserts();

To enable Soft asserts in TestNG (see. documentation):

@Listeners(SoftAsserts.class)
public class SoftAssertTestNGTest {

And here is the result.

In the end of test, it shows all the collected errors:

java.lang.AssertionError: Test userCanUseSoftAssertWithJUnit(integration.SoftAssertJUnitTest) failed.
3 checks failed

FAIL #1: Element should have attribute value=777 {#radioButtons input}
Element: '<input name="me" type="radio" value="master"></input>'
Screenshot: file:/Users/andrei/projects/selenide/build/reports/tests/integration/SoftAssertJUnitTest/userCanUseSoftAssertWithJUnit/1425503251321.0.png
Timeout: 0 ms.

FAIL #2: Element not found {#radioButtons select}
Expected: visible
Screenshot: file:/Users/andrei/projects/selenide/build/reports/tests/integration/SoftAssertJUnitTest/userCanUseSoftAssertWithJUnit/1425503252361.1.png
Timeout: 0 ms.
Caused by: NoSuchElementException: Unable to locate element: {"method":"css selector","selector":"#radioButtons select"}

FAIL #3: Element not found {#xxx}
Expected: visible
Screenshot: file:/Users/andrei/projects/selenide/build/reports/tests/integration/SoftAssertJUnitTest/userCanUseSoftAssertWithJUnit/1425503252697.2.png
Timeout: 0 ms.
Caused by: NoSuchElementException: Unable to locate element: {"method":"css selector","selector":"#xxx"}

    at org.junit.Assert.fail(Assert.java:88)
    at com.codeborne.selenide.junit.SoftAsserts.after(SoftAsserts.java:54)
    at org.junit.rules.ExternalResource$1.evaluate(ExternalResource.java:50)
        ....
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)

Profiler

Now Selenide can create a report about all actions performed during the test. The report includes execution time of every action in milliseconds. It allows you better understand what happens, and what steps take too much time.

Here is an example report:

+--------------------+--------------------------------------------+----------+----------+
|Element             |Subject                                     |Status    |ms.       |
+--------------------+--------------------------------------------+----------+----------+
|open                |http://0.0.0.0:23762/page_jquery.html       |PASSED    |131       |
|#multirowTable      |find elements(by text: Chack)               |PASSED    |100       |
|#multirowTable tr   |find elements(by text: Chack)               |PASSED    |100       |
|#multirowTable tr   |find(by text: Chack)                        |PASSED    |0         |
|by text: Chack      |get attribute(class)                        |PASSED    |139       |
+--------------------+--------------------------------------------+----------+----------+

To enable this report, you need to add the following rule to your tests:

@Rule
public TestRule prettyReportCreator = new PrettyReportCreator();

This is an experimental functionality. Only JUnit is supported by now.

Please try it and give your feedback.

Thanks to kumarunster for this pull request!

Fixed function `$.closest()`

Now the search for parent element by CSS class works correctly:

  $(By.name("firstName")).closest(".active");

Method `$.toString()` now logs all attributes

Method $.toString() logged only defined set of attributes: id, class, type etc. The problem is that Selenium webdriver doesn’t provide API for listing all attributes.

But we found a way! Now method $.toString() prints out all attributes (using JavaScript hack):

      assertEquals("<div class=\"invisible-with-multiple-attributes\" " +
          "data-animal-id=\"111\" id=\"gopher\" ng-class=\"widget\" ng-click=\"none\" " +
          "onchange=\"console.log(this);\" onclick=\"void(0);\" placeholder=\"Animal\" " +
          "displayed:false></div>", $("#gopher").toString());

Upgraded to Selenium 2.45.0.

Please note that this release disables native events in Firefox.

And what’s up with you?

How to test GMail

2014-12-28T00:00:00+00:00

Hi all!

How would you test GMail if you were Google developer? It’s a great exercise, try it once!

Automated testing of GMail is not trivial. It heavily uses ajax, elements are loaded dynamically, loading may take more than few seconds, and there is no reasonable IDs/selectors. You would need to add “wait” for almost every operator!

Project “GMail test”

But it’s possible! In Selenide Examples series we present a github project for testing GMail. It checks inbox content and composes a new message. Then it clicks “Undo”, edits the message body and sends it again. And finally waits until the “Undo” button disappears.

Video

Here is a short video for demonstrating how it works:

Let’s analyze this

Here is the github project: https://github.com/selenide-examples/gmail

Let’s take a look under the hood!

Settings

Before test run we need to set longer timeout, because GMail element tend to load longer than 4 seconds (which is a default timeout in Selenide). Let’s set 10 seconds. Though at some conferences with slow WiFi even 10 was not sufficient long.

  @BeforeClass
  public static void openInbox() {
    timeout = 10000;
    baseUrl = "http://gmail.com";
    
    open("/");
    $(byText("Loading")).should(disappear);
    login();
  }

Have you noticed how we wait until the page gets loaded? This show the power of Selenide: it’s easy to find element by text, and it’s easy to wait until it disappears.

Performing user login is easy:

  private static void login() {
    $("#Email").val(System.getProperty("gmail.username", "enter-your-gmail-username"));
    $("#Passwd").val(System.getProperty("gmail.password", "enter-your-gmail-password"));
    $("#signIn").click();
    $(".error-msg").waitUntil(disappears, 2000);
  }

The last line is needed to fail fast if you configured wrong username or password.

Unread messages counter

In a real life, I would run tests with a predefined data set. Say, with 4 unread messages. And check for presence of text “Inbox (4)”:

  @Test
  public void showsNumberOfUnreadMessages() {
    $(By.xpath("//div[@role='navigation']")).find(withText("Inbox (4)")).shouldBe(visible);
  }

(But our case is harder: we need to test web application with real data that is not constant. Therefore let’s limit ourselves to just check availability of text “Inbox”.)

Verifying inbox content

Unfortunately all the GMail selectors are obfuscated. We cannot ID or other selectors. So, let’s just verify that some texts are present on a page. We know that such messages should be definitely in my inbox:

  @Test
  public void inboxShowsUnreadMessages() {
    $$(byText("Gmail Team")).filter(visible).shouldHave(size(1));
    $$(byText("LastPass")).filter(visible).shouldHave(size(3));
    $$(byText("Pivotal Tracker")).filter(visible).shouldHave(size(3));
  }

Refreshing inbox

GMail interface has a “Refresh” button for reloading inbox. Let’s find it by attribute title=Refresh.

  @Test
  public void userCanRefreshMessages() {
    // In a real life:: INSERT INTO messages ...
    $(by("title", "Refresh")).click();
    // In a real life: verify that the new message has appeared in the inbox
  }

In a real project I would add a new message into database, and verify that the new message has appeared in the inbox after pressing “Refresh” button.

New message

To compose a new message, let’s click the “COMPOSE” button:

    $(byText("COMPOSE")).click();

Enter recipient address, subject and text:

    $(By.name("to")).val("andrei.solntsev@gmail.com").pressTab();
    $(by("placeholder", "Subject")).val("ConfetQA demo!").pressTab();

    $(".editable").val("Hello braza!").pressEnter();
    $(byText("Send")).click();

Isn’t it easy?

And finally, let’s verify that the message has been sent:

    $(withText("Your message has been sent.")).shouldBe(visible);

Undo - redo

There is a very cool (but experimental) feature in GMail - “Undo”. After an email has been sent, you can undo it during next 10 seconds. By clicking the “Undo” button, user can cancel sending the last message and go back to editing. It’s incredibly useful when, say, you sent message to a wrong recipient.

So, let’s try to test “Undo” feature. In the end of previous test, let’s add the following lines:

    $(byText("Undo")).click();
    highlight($(byText("Sending has been undone.")).should(appear));

Edit the message body and send again:

    $(".editable").should(appear).append("Hello from ConfetQA Selen").pressEnter().pressEnter();

    $(byText("Send")).click();

And finally wait for 10 seconds until the “Undo” button disappears:

    highlight($(withText("Your message has been sent.")).should(appear));
    highlight($(byText("Undo")).should(appear)).waitUntil(disappears, 12000);
    $(byText("Sent Mail")).click();

The message has been finally sent.

Now GMail is tested. Google can sleep peacefully. :)

Findings

As you see, web interface without IDs can also be tested. Long loading time and ajax requests are not obstacles. Dynamic content is not stopper. The following are simple receipts to overcome these problems:

Find elements by text
This is how real users behave. This is less dependent on application implementation details.
Test only important things
There are still a lot of things in GMail that left untested. It seems that it’s not possible to test them (unable to use pre-generated test data in tests, absence of static locators). But it’s not that important - important is the fact that the critical functionality is tested: inbox content and sending new message. Always start from testing functionality that is most critical for business.
Use appropriate instruments
Selenide automatically resolves problems with timeouts, ajax, dynamic content, searching by text. Tests are not polluted with long scary XPath. Tests contain only business logic. Tests are readable.

Wish you simple tests!

Andrei Solntsev
selenide.org

How to allocate time for refactoring?

2014-12-17T00:00:00+00:00

One of the most common IT questions is: How to allocate time for refactoring?

It’s common for both developers and testers. Both get very quickly a heap of dirty unreadable code, a plenty of slow, unmaintainable, unreadable tests. It’s getting harder and harder to live with it. Development/testing is getting slower. Motivation decreases. Sometimes you happen to clean up some lines in the evening time, but… it seems to be something wrong with the evening-time work?..

Where is the justice?
Am I the only who needs it?
Why doesn’t my boss allocate me time for refactoring?

I know. I also went through it.

No way

Now, let’s face the truth. If somebody comes to me and asks to allocate one week for refactoring, I will refuse.

Let me explain why. Because refactoring can last endlessly, but somebody should do the work.

10 years ago I was hurt to hear this. Now I am saying it by myself. Moreover, I claim that cleaning code at evening hours is not unfairly - it’s unprofessional.

So, have I lost my ideal?

Absolutely not.

Exactly the opposite. Now I am pretty sure that refactoring is absolutely required. Code must be continuously cleaned up through thick and thin. It just needs to be performed a little bit differently.

You must not ask anybody to allocate a separate time for refactoring. Refactoring is not a separate thing, independent from development/testing. Refactoring is part of coding. Refactoring is part of writing automated tests. It’s the same natural and necessary part as typing, compilation and run.

The following is my receipt:

Small steps!

Recall TDD. Your process should look like this:

Write test (red) - 1 hour
Write code (to make test green) - 1 hour
Refactor (to make code/tests readable and clean) - 1 hour
Make a tea, go to step 1.

This is a continuous process. Small steps. Continuous progress. Hot tea.

(Depending on programming language, project and people “1 hour” can be replaced by “5 minutes” or whatever else.)

But what my boss would think about it?

Nobody will blame you that you are wasting time, if you show continuous progress. If you create new features every day. In case of testers - create new automated tests every day.

Nobody ever got fired for doing feature in 6 hours instead of 5 hours.

Think about it. You boss does not know exactly, how long this feature should be implemented. It means that he can never prove that you wasted additional time for writing tests or refactoring. The opposite is also true - you cannot prove (with facts and numbers) that refactoring speeds up the development time. Both of you can prove nothing. So, just work so as you believe is good to work.

Don’t get me wrong, I am not calling for sabotage. I am not calling for doing your job longer than needed. Just opposite: I believe that this simple receipt lets you do your job faster:

Small steps: Test. Code. Refactor.

So, I don’t need to ask for permission?

If somebody comes to me asking to allocate time for refactoring, I will reject. For the very simple reason: he does not know the TDD mantra. He will almost certainly refucktor this week, and nothing gets remarkably better as a result.

Good doctor doesn’t ask permission to wash his hands before a surgery. Good artist doesn’t ask permission to spend time for tuning his instrument. Somehow all the people understand that this is needed. Without wasting time on washing hands and tuning the instrument, they just cannot do their job well. So, are you worse, my dear professional developers and testers?

But don’t forget that doctor manages to cure at least somebody in a day. And artist manages to play at least few songs per concert. That’s why refactoring for a week, and not refactoring at all are both bad.

Small steps. Continuous progress. Tea with ginger.

And with cookies.

The fast and the continuous @ SQA Days 16

2014-12-13T00:00:00+00:00

This is a video from my presentation “The fast and the continuous” on the last SQA Days 16 conference in Saint-Petersburg (Russia).

The video is in Russian.

The fast and the continuous from Vlad Orlikov on Vimeo.

Video of Andrei Solntsev presentation on SQA Days-16
November 14-15 2014, Saint-Petersburg, Russia
www.sqadays.com

You find wrong bugs

2014-12-09T00:00:00+00:00

When I was on the last SQA Days conference in Saint-Petersburg, there happened an incident. At that moment, I didn’t realize what happened. I just smiled. And only a few days later I got the idea.

So,

when I finished my speech about really effective automated testing, a man took a microphone and started asking criticizing questions. After a few answers of mine, he sat down discordant, saying:

You find wrong bugs.

I just smiled.

Only a few days later I caught up why he was basically wrong.

No, I am not going to say that we find good bugs.

I am going to say that

WE DO NOT SEARCH FOR BUGS AT ALL.

What is Quality Assurance

This is very, very important. Every QA engineer should know it from the childhood.

QA means “Quality Assurance”. It means “being sure that software works”. Our first job is not to find all bugs. Our first job is to be sure that software does its job.

For example

If we develop an internet-shop for selling TVs, the job of QA is to assure that user can find TV, press the big “Buy” button and pay money. This is the most important job.

Maybe banner looks bad. Maybe “Print PDF” button opens a new empty window. May be the “login” disappears sometimes. Surely, these are errors, but these are secondary errors. Surely, it’s bad if you have such errors, but the business still will work. But if the “Buy” button is not clickable - it’s the end of the business. User cannot pay his money. It’s a big difference!

And there are a plenty of thirdly errors - when user enters 1000 chinese characters into “login” field and gets 500 error. No one normal user will do that. And if he does, let him get this 500 error.

I am not saying that these secondary and thirdly errors should not be searched and fixed. Sure, You should find and fix them. But only when you are sure that the business works.

So,

the main conclusion:

Your first test should be “green path”. A typical scenario that bring the money:
Find TV - “Buy” - pay. Whatever you do: write automated tests or test manually. Your first test - green path.

This approach has one psychological disadvantage. This is the most boring test. This is a guarantee to find less bugs than your colleagues. This is a guarantee to make your boss feeling that you are not doing anything useful. But this is still the most important job of QA department.

All these stupid tests about “1000 chinese characters in the login field” - you can do them, but only if all other things are ok. And you have free time that you cannot spend to anything else. In practice, that means - never.

But this is exactly the sort of bugs that QA engineers do generate during every release. Again and again. These meaningless bug reports waste your time, waste your resources, waste your attention, thus letting the real bugs appear unnoticed.

But this is a guarantee to find 50 new bugs at every release. This is a guarantee to get a top employee of the month. It’s call “local optimization”, and this is the most powerful of devil’s inventions.

Do not run chase for bugs. You cannot catch all bugs in the world. It’s like pimple: you squeeze one - three more will appear. You don’t need to watch the pimples - you need to monitor the overall health. Do sport, do healthy eating, do hygiene - and pimples will disappear automatically. Do write the most important tests first. Make them fast. Make them stable. It’s better to have tests green (and you will feel alarm when then get red once) than having a lot of tests red (and nobody will catch sight of the real problem).

That’s because I am saying:

We do not search for bugs

We assure that software works. We write automated test to assure that user can buy TV. It allows us to avoid wasting time for maintaining plenty of meaningless bug reports and useless tests. It frees up our resources for quickly reacting to real problems that will always appear in production, not depending on QA department existence. It allows us to develop and maintain a complicated software with a small team. Small, but very effective team.

In testo veritas!

Changes in Selenide 2.15

2014-11-03T00:00:00+00:00

Good evening!

Good news: we have released Selenide 2.15. This time we have a lot of new features.

Sizzle selectors (CSS3)

Now you can use CSS3 selectors in Selenide for searching web elements!

For example:

$(":contains('Tere Martin!')").shouldBe(visible);
$(":not(a#id)");
$$(":not(div,p)").shouldHave(size(3));
$("[value!='johnny']");
$("div:has(span)");
$(":input");
$(":text");
$(":checkbox");
$(":file");
$(":password");
$(":image");
$(":header");
$(":first");
$(":last");
$(":even");

To enable Sizzle selectors, add this line to your tests:

Configuration.selectorMode = Sizzle;

Feel free to share your experience with us. Did it work for you?

Multifile upload

Now functions $.uploadFile() and $.uploadFileFromClasspath() can accept multiple arguments. This means that you can upload multiple files with Selenide!

Standard Selenium webdriver doesn’t provide such function, so we had to make it with a help of black magic. Please share your experience, if it worked for you.

Support for BrowserMob proxy

We added convenient way for Selenide to add Proxy server to webdriver. First of all, it was needed for BrowserMob proxy - a popular tool among testers. It allows to intercept http requests between web application and browser, thus making possible many things that are now allowed with pure Selenium webdriver:

file download from server,
authorization on site,
asserting HTTP statuses,
and so on

Thanks to Vladimir Denisov for this pull request!

Here is an example of using BrowserMob Proxy with Selenide ProxyServerUsageTest.java:

ProxyServer proxyServer = new ProxyServer(findFreePort());
proxyServer.start();
proxyServer.newHar("google-test");
WebDriverRunner.setProxy(proxyServer.seleniumProxy());

open("http://google.com");

List<HarEntry> harEntries = proxyServer.getHar().getLog().getEntries();
assertTrue(harEntries.get(0).getRequest().getUrl().equals("http://google.com"));

You can zoom page now!

You can find sample usage in tests:

import static com.codeborne.selenide.Selenide.*;

zoom(2.0); // Enlarge page zoom twice
zoom(0.5); // Zoom out twice

It can be useful for testing responsive design.

Support for JSON and iCal

You can now open non-html pages with Selenide.

It can be useful for testing json, iCal etc. resources. Sometimes it’s useful to check them inside UI tests.

assertThat(source(), containsString("DTSTART:20140409T090000"));

Support for tabs and windows/tabs

Now Selenide allows switching between tabs/windows/frames not only by title, but also by index (0, 1, 2, …).

Examples of switching between frames:

switchTo().frame(0);
assertTrue(source().contains("Hello, WinRar!"));

switchTo().defaultContent();
switchTo().frame(1);
$("h1").shouldHave(text("Page with dynamic select"));

Examples of switching between tabs:

switchToWindow(1); 
$("h1").shouldHave(text("Page with JQuery"));

switchToWindow(2); 
$("h1").shouldHave(text("File uploads"));

switchToWindow(3); 
$("h1").shouldHave(text("Page with alerts"));

switchToWindow(0); 
$("h1").shouldHave(text("Tabs"));

Support for Allure Framework

We have added function to get screenshot as a file:

import static com.codeborne.selenide.Screenshots.getScreenShotAsFile;

File screenshot = getScreenShotAsFile();

It can be used for integration with Allure Framework.

Thanks to Vladimir Denisov for this pull request!

Upgraded to Selenium 2.44.0.

Note that it brings upgrade of Google Guava to version 18.0.
Unfortunately, PhantomJS 1.2 does not work with Selenium webdriver 2.44.0 :( We have already committed Pull Request to ghostdriver for ghostdriver. Now waiting until it gets released.

And what’s up with you?

How to start writing UI tests in 10 minutes

2014-10-01T00:00:00+00:00

Hi!

People often ask: how to learn writing tests? How to start? How to write first test in Selenium?

Now we have an answer!

This video tutorial demonstrates how to create a project with Maven and write a test that opens a Google in browser, enters a word and checks for search results.

How to start writing UI tests in 10 minutes from Selenide on Vimeo.

Selenide tutorial

Please feel free to give your feedback!

Changes in 2.13 and 2.14

2014-09-28T00:00:00+00:00

Hi Seleniders!

In September we released two versions of Selenide: 2.13 and 2.14. There is not so much new functions, but there is one new function that I want to discuss with you. Let’s start with it.

Fast method $.setValue

In Codeborne we analyzed performance of tests in few real projects and discovered that the most slow part of tests is filling text fields (not XPath search as many of us think). In other words, method $.setValue (or WebElement.sendKeys) is the bottleneck. It’s because Selenium emulates keypress of every single key with all related events: keyDown, keyUp etc. - thus making method sendKeys quite slow.

It’s possible to disable generating events, but in this case some functionality will be broken that uses these events: autocompletion, autosuggestions etc.

We have found a solution. Let’s Selenide have two separate methods: $.sendKeys and $.setValue. The first one will work like Selenium by default: slowly and with generating events. The second one will be fast, setting values to text fields using JavaScript. So test author can decide in which case which method is needed. In most cases the fast method $.setValue can be used, because there is not so much autocompletions comparing to “regular” text fields.

In our projects using of fast $.setValue method gave 10% of performance improvement.

NB! This is experimental feature. It can be enabled by flag -Dselenide.fastSetValue=true. By default it’s disabled, thus $.setValue works exactly the same as $.sendKeys.

Added method for checking images `$("img").isImage()`

Method $("img").isImage() returns true if the image has been correctly loaded. The method can be used only for <img> elements.

An example of usage can be found in test ImageTest.

NB! The functions does not work in HtmlUnit.

Added possibility to add descriptions to asserts (like in JUnit and TestNG asserts)

Now you can add a custom message to all should-methods:

$("#kpp").shouldBe("Private customers cannot have KPP", empty);

In case of test failure this description will be added to the error message:

Element should be empty {By.id: kpp} because Private customers cannot have KPP
Element: '<input id="kpp">012973891263</input>'
Screenshot: file:/Users/andrei/projects/selenide/build/reports/tests/integration/SelenideMethodsTest/waitUntilMethodMayContainOptionalMessageThatIsPartOfErrorMessage/1411898416054.0.png
Timeout: 4 s.

I am not sure that this feature is designed in the most convenient way. So, I am waiting for your suggestions. How could it be made more easy to use?

Maybe this API would be more convenient?

$("#kpp").shouldBe(empty.because("Private customers cannot have KPP"));

But in this case you will need to duplicate the description if you want to check multiple conditions in a line.

One more option:

$("#kpp").because("Private customers cannot have KPP").shouldBe(empty);

And finally, the “because” word is doubtful: in different situations you may find more appropriate to use other words.

What do you think?

Added wrappers `be` and `have`.

Now you have alternative way to write checks:

$("#username").should(have(text("Ivan")));
$("br").should(be(empty));

It may be useful when using Selenide with frameworks like EasyB that also use terms shouldBe or shouldHave for their needs.

Upgraded to Selenium 2.43.1.

Many testers have been waiting for this upgrade for a while. First of all, because of FireFox 32 support. And also because of new InternetExplorer driver.

We have not encountered any problems with the new Selenium 2.43.1.

And what’s up with you?

Selenide usage simple notes: IE, TestNG, Bootstrap dropdown

2014-08-25T00:00:00+00:00

Hello!

My name is Sergey Shimkiv. Below you can find some notes about Selenide/Selenium usage.

IE notes

IE 11 x32/x64. In some cases after the actions with HTML elements (click() for example) you can receive an exception.
The cause of it could be synthetic events usage. The workaround is to use native events for IE:

   capabilities.setCapability("nativeEvents", "true");

https://code.google.com/p/selenium/wiki/InternetExplorerDriver

One way to add Selenide screenshot into the TestNG HTML reporter

In some cases you might want to add Selenide’s screenshots of failed tests into your TestNG HTML reporter.

For example: You write two tests (Test1 and Test2) which must be linked (Test2 depends on Test1 results). But you know that Test1 will fail because of application bug(s). So you will write something like this:

   @Test(...)
   public void Test1() {
    ...
    try {
      // Test block with known bug
    } catch(...) {
      // Some actions
    } finally {
      // You want to perform some actions here to ensure correct preconditions for the Test2
    }
   }

Let’s assume that you’re using own test listener that extends TestListenerAdapter. And you have overridden onTestFailure(ITestResult result) method to collect some additional information into the HTML report - your own screenshots for example. In such case it is possible that your screenshot gathering implementation will collect incorrect data because finally block can be performed before screenshot will be taken.

Just keep in mind that Selenide’s screenshot file name (that will be taken directly after some exception) could be taken from result.getThrowable().getMessage();

One way to work with customized Bootstrap HTML elements

Tests often get complicated when you need to test customized HTML controls with complex logic.

For example, Bootstrap’s dropdown elements are represented via set of HTML elements. In common:

  <div class="dropdown">
    <button class="btn btn-default dropdown-toggle" type="button" id="dropdownMenu1" data-toggle="dropdown">
      Dropdown
      <span class="caret"></span>
    </button>
    <ul class="dropdown-menu" role="menu" aria-labelledby="dropdownMenu1">
      <li role="presentation"><a role="menuitem" tabindex="-1" href="#">Action</a></li>
      <li role="presentation"><a role="menuitem" tabindex="-1" href="#">Another action</a></li>
      <li role="presentation"><a role="menuitem" tabindex="-1" href="#">Something else here</a></li>
      <li role="presentation" class="divider"></li>
      <li role="presentation"><a role="menuitem" tabindex="-1" href="#">Separated link</a></li>
    </ul>
  </div>

The problem is that the <ul> element initially is not visible for the Selenium (and for Selenide too). To be able to select some dropdown element value you can:

   SelenideElement parentDiv = $(".dropdown");
   
   // Find `<button>` element and `click()` on it
   parentDiv.find("button").scrollTo().click();
   
   // Now you can find needed dropdown element value by text
   parentDiv.find(".dropdown-menu").find(withText("Action")).parent().click();

In the next post I would like to share experience in the automated testing environment deployment (based on Grid2).

Thanks to the Selenide’s authors for their great tool ;)

Sergey Shimkiv

Shorten your code

2014-08-08T00:00:00+00:00

Hi all!

This is Prezi presentation about Selenide from Ashwin Dalvi.

Pros, Cons and Myths:

Selenide: Shorten your code!

Changes in Selenide 2.12

2014-07-05T00:00:00+00:00

Hello QA geeks!

Great news: we have released Selenide 2.12. Let’s see what’s coming with it.

Added function $.uploadFile(File)

The function allows you to upload a file.

   File cv = new File("src/test/resources/cv.pdf");
   $("#cvFileUpload").uploadFile(cv);

Selenide already had a similar function $.uploadFromClasspath(String fileName). It searched the file for uploading in classpath. We believe that holding test file together with test sources is a good practice (meaning that test files get to classpath during project compilation).

But we realized that sometimes it’s convenient to upload some file from another place.

Fixed function $.uploadFromClasspath

It appeared that webdriver fails when trying to upload a file like c:/src/test/java/../resources/cv.pdf. We improved function $.uploadFromClasspath, so that it removes extra “..” parts from file name.

   $("#cvFileUpload").uploadFromClasspath("cv.pdf");

Function $.val(“john”) also works for selects

Function $.val has got a little bit smarter. It called on SELECT field, it chooses the right OPTION with corresponding value. This is one more step towards the idea that developer doesn’t need to think about implementation details and can concentrate on business logic. You just write $("#sex").val("female") and don’t think either it’s INPUT or SELECT - Selenide detects it automatically and performs required action.

Technically, $("select").val("yes") - is a synonym for $("select").selectOptionByValue("yes").

Added function `getWebDriverLogs()`.

The function reads webdriver logs. Technically it’s synonym for webdriver.manager().logs(). In theory, these logs can contain very useful information about browser errors, javascript errors, performance problems etc. In practice, webdriver logs are not well supported by all webdrivers. We do not understand how to use them efficiently. Please share with us if you have any experience with webdriver logs!

Upgraded to Selenium 2.42.2 and HtmlUnit 2.15

We haven’t experienced any problems with the new Selenium.

Thanks again to Selenium authors for the great product!

And what’s new with you?

Changes in Selenide 2.11

2014-05-23T00:00:00+00:00

Hello!

We have released Selenide 2.11. It does contains no new features, but removes old unused features, that made our life complex and broke down the progress.

Please be so nice and run your tests with Selenide 2.11. Notify us if some tests got broken.

What we cleaned up

Removed dependency on jQuery

Methods $.selectOption() and $.selectOptionByValue() tried to trigger “change” event using jQuery. It was done a long time ago to fight against some odd test failures on Windows in IE. Now it’s actual anymore

at least all our tests are passing without this hack.

The whole class com.codeborne.selenide.JQuery is marked as deprecated. Please be sure that you do not use it in your tests.

Cleaned up annoying logs

When closing Firefox, you could see the following annoying error message in log:

“UnreachableBrowserException: Error communicating with the remote browser. It may have died.”

We researched this problem and found that this is a bug (or feature?) of Selenium Firefox webdriver. When calling method webdriver.close() it throws UnreachableBrowserException, but still closes the browser (at least, in Linux and Mac OS).

We removed this pointless log.

And what we updated

Upgraded to PhantomJS 1.2.0

As before, all tests of Selenide itself run successfully in PhantomJS, but some tests in our real projects fail. That’s why we still cannot use PhantomJS in real work.

And what’s new with you?

Changes in Selenide 2.10

2014-04-27T00:00:00+00:00

Hi all!

Recently we released Selenide 2.10. Let me introduce you the news!

New functions

Working with windows/tabs

Selenium WebDriver does not support convenient API for working with windows and tabs. It only suggests method getWindowHandles() that returns set of strings - identifiers of opened windows. It’s not trivial to find the needed one from these handles.

As Selenide primary goal is to free developer’s head from browser technical details, we want to make working with windows/tabs easy and intuitive. We started this movement from a simple thing: we have added method

Selenide.switchToWindow(String title)

You can find a sample usage in Selenide tests:

@Test
  public void canSwitchToWindowByTitle() {
    $(byText("Page2: alerts")).click();
    $(byText("Page1: uploads")).click();

    switchToWindow("Test::alerts");
    $("h1").shouldHave(text("Page with alerts"));

    switchToWindow("Test::uploads");
    $("h1").shouldHave(text("File uploads"));
  }

We are planning to continue working on simplifying windows/tabs API - probably with help of new Java 8 features.

How would you like to use windows? Please feel free to share your ideas!

New methods `$.hover()` and `$.dragAndDropTo(target)`

Method $.hover() emulates moving mouse over the element (without clicking). Find example here.

Method $.dragAndDropTo(target) can drag an element and drop into another element. Example:

  $("#from").dragAndDropTo("#to")

New methods for searching parent/ancestors `$.parent()` and `$.closest()`

I often need to get a parent element. Or even ancestor, not direct parent. For example, I often search a DIV by text - this DIV is located inside a table. Then I want to find the table row containing the DIV. The only way to find it was using XPATH.

Now you can use convenient $.parent() or $.closest() methods:

  $(byText("Row 1")).parent();
  $(byText("Row 2")).closest("tr");
  $(By.name("firstName")).closest(".form");

You can find more examples here

Tracing JavaScript errors

Now Selenide tries to automatically catch all JavaScript errors that happened on a page.

What we do we them?

First of all, Selenide automatically adds JS errors to the error message when your test fails. Basically, it’s sufficient. If you want more control, you can use the following methods:

Selenide.getJavascriptErrors() - returns all JavaScript errors on current page.
Selenide.assertNoJavascriptErrors() - fails the test if there have been some JavaScript errors on current page.

P.S. By now it’s implemented very simply (using the window.onerror function). I am not sure it works pretty well in all browsers. And it cannot catch all errors. So, feel free to share you ideas how to implement it better.

Bugfixes and improvements

Closing webdrivers

Mechanism of automatic closing webdrivers was improved for case when one of webdrivers is hanging (and thus cannot be closed and prevents closing of other webdrivers). Thanks to Aleksander Gavrilenko for this nontrivial fix!

Selenide does not wait for <body>

Method open(url) doesn’t wait until the tag <body> appears in the document. This is just an old code that is not needed since Selenide automatically waits for required conditions.

Upgrade to Selenium 2.41.0

As usually, we upgraded to latest Selenium WebDriver version.

We haven’t observed any problems with the new Selenium. It works.

Other news

March statistics of Selenide downloads is just great!

We became twice as much during one month! Wow!

And what’s new with you?

Changes in Selenide 2.9

2014-03-15T00:00:00+00:00

Good evening!

Today was released Selenide 2.9. Let me tell you about the changes in the new version.

New functionality

Added support for Safari browser

Indeed, Safari driver doesn’t seem to be stable yet. At least, some Selenide tests still fail on Safari.

Another problem with Safari is that it doesn’t support JS alerts and cannot open local files like file://c:/tmp.txt.

Please feel free to share your experience with Safari webdriver!

Added condition `or`

Now you can declare composite conditions like this:

    Condition completed = or("completed", started, inProgress, loading);

and use them in your tests:

    $("div#page").shouldBe(completed);

Actually I am not sure it’s a good idea. I believe that test should always know exactly, in which state the element should be at any moment. But folks insisted that or condition can be useful.

Added method `ScreenShooter.to(folder)`

Now JUnit users can declare screenshooter like this:

public class MyTest {
  @Rule
  public ScreenShooter photographer = failedTests().to("test-results/reports");
}

In most cases it’s not needed, because path for screenshots can be declared using system property: -Dselenide.reports=test-results/reports or programmatically: Configuration.reportsFolder=test-results/reports. So, the new method can only be useful if you need different paths for different tests.

Bugfixes and improvements

Method `$.download()` throws `FileNotFoundException` (if server returns 40x error) or `RuntimeException` (for 50x status)

In older versions, method $.download() returned an empty file in case of server error during downloading file. It’s certainly not convenient for testing.

Chrome browser window is also maximized.

Because of a bug in ChromeDriver Chrome browser window was not maximized. Now it is. Indeed I had to use java.awt black magic for this.

Method `$.shouldHave(text())` also ignores the \u00a0 character (so called “non-breaking space”)

In older versions, a check $(".error").shouldHave(text("Hello, Johny!")) ignored spaces and tabs. But we forgot about the \u00a0 characters which is widely used in web - e.g. for formatting amounts and dates. For example, this check could fail:

  $(".amount").shouldHave(text("123.45 EUR"));

Now it works.

Improved automatic closing of browser window in case of multi-threaded tests run with TestNG

In older versions, Selenide opened and closed browser in the same thread. In most cases it’s sufficient.

But folks found that TestNG executes tests and @AfterSuite methods in different threads. We had to rework this code. Now Selenide watches all threads and automatically closes unused browser windows once corresponding threads are done.
P.S. Let me remind you that you do not need to manually close webdriver, because Selenide does it automatically.

Including webdriver exception

When a check like $.shouldBe(visible) fails because of webdriver exception, this error is not ignored anymore, but added to a standard Selenide error message like Element should be visible. It can be possible if browser behaves incorrectly. For example, folks found that IE sometimes throws InvalidSelectorException for a valid XPath.

If Selenide fails to take screenshot, it logs corresponding exception with stack trace.

Actually I am not sure that it’s really useful. To avoid spamming logs, Selenide writes stack trace only once (on the first error).

Selenide saves page source in correct encoding (UTF-8)

In older versions, Selenide could store page HTML in wrong encoding, depending on default system preferences.

Removed INFO messages about “reportsUrl” and “BUILD_URL”

Some users were confused by these messages.

Indeed, it’s a really fantastic feature: Selenide can automatically take screenshots and make them available as HTTP links in Jenkins reports. I will write a separate blog post about this feature.

Using “`jQuery`” word instead of “`$`”

Sometimes Selenide used character “$” to support javascript events. It could cause problems when testing applications using both jQuery and Prototype (or some other JS framework).

Upgraded to Selenium 2.40.0, HtmlUnit 2.14 and TestNG 6.8.8

As usually, we upgraded to last versions of Selenium and TestNG.

NB! In the latest TestNG 6.8.8 was removed JUnit support. So be careful if you use both TestNG and JUnit in your project, and the latter was loaded transitively. Now you will need to add JUnit dependency explicitly.

So, life is going on!

And what’s new with you?

Selenide downloads: over 200 unique ips

2014-03-12T00:00:00+00:00

As you probably know, the Central Maven Repo publishes download statistics for different artifacts.

Today was published Selenide download statistics for February, 2014. The image below shows number of unique IPs that downloaded selenide.jar from the central maven repository.

It seems that we have great success! Yeah!

Selenide in five minutes by Glen Smith

2014-03-11T00:00:00+00:00

Wow!

Glen Smith presented Selenide at Canberra JUG. This is a really great 5-min live demo of Selenide. It took only 5 minutes to tell, write and run a full working test for google image service. You know, it’s not that easy: there is Ajax under the hood…

Please enjoy!

Original blog post: [Selenide in Five Minutes: A lightning talk](http://blogs.bytecode.com.au/glen/2014/02/13/selenide-in-five-minutes-a-lightning-talk.html)

Glen Smith is an Australian engineer, co-author of “Grails in Action” book.

You can find more info in his blog.

Good job, @glen_a_smith!

Selenide T-shirt

2013-10-04T00:00:00+00:00

Hi seleniders!

You could have noticed that Selenide has got a new logo and design.

And even own T-shirts! Like real men!

We will share three of these T-shirts next week on the XP Days conference in Kiev.

Selenide Harlem Shake

2013-08-29T00:00:00+00:00

Good morning!

This is a video demonstrating how easy is to start writing automated tests with Selenide.

We wanted to make a screencast that would be short, funny and informative enough. By the way, this is a real-life project, not another “Hello World” application.

Watch with sound!

Selenide Harlem Shake from Selenide on Vimeo.

Can PhantomJS take screenshots?

2013-07-15T00:00:00+00:00

Many people think that PhantomJS (as a headless browser) cannot take screenshots.

This is not true!

According to PhantomJS documentation, it can take screenshots.

Let’s try to do that.

import static com.codeborne.selenide.Selenide.*;

public class TestPhantomScreenshot {
  public static void main(String[] args) {
    System.setProperty("browser", "phantomjs");
    open("http://google.com");
    screenshot("google-com-screenshot");
    close();
  }
}

It works!

Though, it does not work ideally. Well, screenshots of google.com, habrahabr.ru and skype.com look good, but screenshot of selenide.org is quite strange.

Does it mean that PhantomJS is not mature enough yet? I don’t know. But at least PhantomJS can do screenshots.

Video: Selenide on SeleniumCamp 2013

2013-05-09T00:00:00+00:00

This is our talk about Selenide on SeleniumCamp 2013 conference in Kiev.

The talk is in Russian.

First part - introduction to Selenide:

Second part - live demonstration of Selenide:

pair programming
ping-pong programming
programming a real internet bank

What is Selenide

2013-04-23T00:00:00+00:00

Many of you have tried Selenium WebDriver - one of the most popular tools for UI Testing.

Writing UI Tests is not simple. There are a number of typical problems, including Ajax, dynamic pages and timeouts. The goal of Selenide is to resolve these problems.

What is Selenide

Selenide is a wrapper for Selenium WebDriver that allows you easier and faster writing of UI Tests. With Selenide you can concentrate on business logic instead of solving all these endless browser/ajax/timeouts problems.

This is an example of UI Test. As you see, the amount of code is minimal. Just type open - and browser comes.

@Test
public void testLogin() {
  open("/login");
  $(By.name("user.name")).sendKeys("johny");
  $("#submitButton").click();
  $("#username").shouldHave(text("Hello, Johny!"));
  $(".error").shouldNotBe(visible);
}

When you first execute open, Selenide automatically runs web browser and opens page http://localhost:8080/login (host and port are configurable). And closes the browser automatically when all tests are finished.

Selenide key features

Shortly, these are the key features of Selenide

Concise API inspired by jQuery
Automatic handling of most problems with Ajax, waiting and timeouts
Automatic handling of browser lifecycle
Automatic screenshots on test failures

In short, the purpose of Selenide - is to focus on business logic and not to engage in perpetual annoying minor problems.

Additional methods

Selenide provides additional methods for actions that cannot be done with a single command in Selenium WebDriver. These are radiobutton selection, selectbox selection, taking screenshots, clearing browser cache etc.

@Test
public void canFillComplexForm() {
  open("/client/registration");
  $(By.name("user.name")).setValue("johny");
  selectRadio("user.gender", "male");
  $(By.name("user.securityQuestion")).selectOption("What is my first car?");
  $(By.name("user.preferredLayout")).selectOptionByValue("plain");
  $("#submit").followLink();
  takeScreenShot("complex-form.png");
}

@Before
public void clearCache() {
  clearBrowserCache();
}

How Selenide overcomes Ajax?

Ajax is PITA (pain in the ass) for UI Testers.

Nowadays most of the applications use Ajax. When testing web application that uses Ajax, you need to invent code that waits for something. Wait until button gets green, wait until div gets required text, or wait until error message disappears. You can find tons of web pages suggesting tricks how to make Selenium wait something.

Selenide resolves this problem like no other. Unbelievably simple! While Selenium provides you a rich API for waiting different events see this for example, Selenide suggests you just to not bother. If you want to check that button is green, but button is not yet green, Selenide just waits until the button gets green. (Of course, timeout is configurable. Default is 4 seconds). It’s an unique solution - as easy and stable as possible.

Enjoy code samples:

@Test
public void pageUsingAjax() {
  $("#username").shouldBe(visible);   // waits until elements appears
  $("#username").shouldHave(text("Hello, Johny!")); // waits until elements gets text "Hello, Johny!"
  $("#login-button").shouldHave(cssClass("green-button")); // waits until button gets green
  $("#login-button").shouldBe(disabled); // waits until button gets disabled
  $(".error").shouldNotBe(visible);  // waits until element disappears
  $(".error").should(disappear);     // try to the same with a standard Selenium WebDriver!
}

How to make screenshots automatically?

That’s easy! If you are using JUnit, just add this line to your base test class:

   @Rule
   public ScreenShooter makeScreenshotOnFailure = ScreenShooter.failedTests();

This line will cause Selenide to automatically take screenshot after every failed test. For your convenience, Selenide creates even 2 files: .PNG and .HTML.

If you want to shot all tests (not only failed), you can use this line:

   @Rule
   public ScreenShooter makeScreenshotOnEveryTest =
              ScreenShooter.failedTests().succeededTests();

TestNG users can add this annotation to their base test class:

@Listeners({ ScreenShooter.class})

I want to try, how to start?

Just add Selenide dependency to your project:

<dependency>
    <groupId>com.codeborne</groupId>
    <artifactId>selenide</artifactId>
    <version>7.9.2</version>
</dependency>

Import required classes:

import static com.codeborne.selenide.Selenide.*
import static com.codeborne.selenide.Condition.*

and it’s ready! Start writing tests!

Why yet another testing library?

We have been using Selenium in different projects. And we discovered that every time we need to write the same code in order to start browser, close browser, take screenshots and so one. You can find a huge amount of topics ala “How to do this and that in Selenium” with a huge amount of code that you need to copy-paste into your project.

We asked yourself: why should UI Testing be so tedious? We decided to extract our repeating code into a separate open-source library. That’s how Selenide was born.

Does somebody use Selenide?

Yes. In Codeborne we have been using Selenide for 2 years in different project:

Internet-banks
Self-service portals
etc.

with different languages and testing frameworks:

Java + ANT + JUnit
Java + Gradle + JUnit
Scala + ANT + ScalaTest
Groovy + ANT
etc.

So you can be sure that Selenide is not just another raw open-source project. It’s actually used and supported.

Show me a working example!

You can find a reference open-source project that uses Selenide: Hangman game.

We have also created project Selenide examples, where you can find examples of using Selenide for testing different sites like Gmail and Google.

What means the name “Selenide”?

In chemistry, Selenide is chemical compound containing Selenium + something.

So for UI Tests:

Selenide = Selenium + JUnit
Selenide = Selenium + TestNG
Selenide = Selenium + ScalaTest
Selenide = Selenium + whatever

Enjoy the open-source chemistry!

We would be glad to get your feedback - tell us what you tried, how it worked. What succeeded, what failed? Feel free to write your feedback or questions to googlegroup or privately to me!

Selenide

Released Selenide 7.9.2

Fixed colors on video

Before

After

Optimized video recorder

Attach video files

Updated to Selenium 4.32.0

Fixed ClassCastException

Slightly improved loops performance

Released Selenide 7.9.0

Attach screenshots to Jenkins and GitLab

Click holding keys

Upgrade to Selenium 4.31.0

Check for empty expected value

Released Selenide 7.8.0

New functions for Appium

Remove proxy filters

Annotation @ShadowHost

Combined attributes in reports

Upgraded to Selenium 4.30.0

News

Released Selenide 7.7.0

Added support for Moon

Added method $.scroll() with parameters

Fixed Selenide on Java 22

Updated MITM certificate for Selenide proxy

Year summary

Milestones

Elves

Serhii Bryt

Boris Osipov

Petro Ovcharenko

Yaraslau Lazakovich

Aliaksandr Rasolka

donnieHub

Daniil Moiseev

Erik Jõgi & Vlad Ogorodnik:

Amuthan Sakthivel:

Wizards

Palantirs

Tribes

People

Released Selenide 7.6.0

Added video recorder

Added because for webdriver conditions

Added method $.scrollIntoCenter()

Special space characters support

Fixed inNewBrowser with custom configuration

Fixed appium page factory

Reduced the number of Selenide logs

Fixed Selenide.screenshot(filename) behaviour

JSR305 -> JSpecify

Simplified custom commands

Updated dependencies

News

Statistics

Released Selenide 7.5.0

New configuration for every browser

Fixed events in selects

Shorter API for downloading files

Don’t close windows when downloading files

Don’t catch all Errors anymore

Fixed custom error formatters

Updated dependencies

News

Statistics

Released Selenide 7.3.1

Mock response with specific content type

Fixed method $.clear() in mobile

Fixed error message when clicking an invalid link

Disabled Chrome warning about stolen password

Fix CDP downloading for custom webdrivers

Deprecated setting holdBrowserOpen

Upgraded Selenium from 4.19.1 to 4.20.0

Statistics

Released Selenide 7.2.0

Download files from Selenium Grid

Download files remotely using CDP

Collections for mobile tests

Annotation `@ShadowHost`

Added method `$.scroll()` with parameters

Added `because` for webdriver conditions

Added method `$.scrollIntoCenter()`

Fixed `inNewBrowser` with custom configuration

Fixed `Selenide.screenshot(filename)` behaviour

Fixed method `$.clear()` in mobile

Deprecated setting `holdBrowserOpen`

Error message for element without `href`

Condition `animated` for waiting for the completion of an animation

New method `$.unfocus()`

Restore method `isEmpty()` for collections

Return field `self` in containers

Renamed `CollectionCondition` to `WebElementsCondition`

Removed deprecated methods in `Condition`

Removed deprecated methods in `CollectionCondition`

Removed deprecated methods in `ElementsCollection`

Replaced deprecated class `ElementsContainer` by interface `Container`

Replaced `FileNotFoundException` by `FileNotDownloadedError`

Renamed `Exception` to `Error`

Removed support for deprecated `WebDriverEventListener`

Removed deprecated methods `$.getSelectedValue()` and `$.getSelectedText()`

Removed deprecated TestNG annotations `@Report` and `@GlobalTextReport`

New method `$.highlight()` for highlighting a web element

Replaced `ElementsContainer` by `Container`

Methods `$.tap()`, `$.doubleTap()` for mobile apps

Added method `$$.getOptions()`

Method `getFocusedElement()` made lazy

Added support for `SelenideAppiumElement` fields in page objects

Don’t inherit page objects from `ElementsContainer`

Added support for `$.type()` in mobile apps

Fixed method `$.type(Keys.*)`

Removed leading/trailing spaces from `$$.texts()`