Selenide

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?

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 loose 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 checks 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 we 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](https://github.com/selenide/selenide/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 becase 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 logs 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 developed a third method FOLDER. Probably you need this method - 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

Selenide

Released Selenide 6.18.0

Show actual texts in collections

Updated Selenium from 4.11.0 to 4.12.1

Restore BasicAuth via DevTools

Added method $$.getOptions()

Method getFocusedElement() made lazy

Added support for SelenideAppiumElement fields in page objects

Precise scrolling in mobile apps

Don’t inherit page objects from ElementsContainer

Updated dependencies

Statistics

Released Selenide 6.17.2

Un-hanged the hanging webdriver. Again.

How to reproduce the problem

Released Selenide 6.17.1

Un-hang hanging webdriver

Added support for $.type() in mobile apps

Fixed method $.type(Keys.*)

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

Released 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

Released Selenide 6.16.1

Added conditions allOf and anyOf

Added checks for cookies

Updated WebDriverManager from 5.4.0 to 5.4.1

Fixed support for <tspan> in SVG

Released Selenide 6.16.0

Speed up collection checks

Improved error messages in collection checks

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

New methods for setting time

Full stacktrace in soft asserts

Improved BasicAuth in Chromium browsers

Multiple domains in BasicAuth

Fixed $.doubleClick() in Appium

Take screenshot earlier

Updated dependencies

News

Released Selenide 6.15.0

Merged project selenide-selenoid into selenide

Merged project selenide-appium into selenide

Now Click checks that the 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

What does it give us?

News

Released Selenide 6.14.0

Speed up debugging

Removed Chrome argument --no-sandbox

Added method step for reports

Added method $.dragAndDrop(DragAndDropOptions) with options

Allow to set browser position out of screen

Allow setting path to Edge browser binary

Updated dependencies

News

Statistics

Released Selenide 6.13.0

Added method $.cached()

Added http status to server response mock

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

Added method $.doubleClick(options)

Added condition $.shouldHave(innerText())

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

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

Fixed bug in method $$.subList()

Updated dependencies

News

Released Selenide 6.13.0

Banners support

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()`

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

Added conditions `allOf` and `anyOf`

Fixed support for `<tspan>` in SVG

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

Fixed `$.doubleClick()` in Appium

Merged project `selenide-selenoid` into `selenide`

Merged project `selenide-appium` into `selenide`

Removed Chrome argument `--no-sandbox`

Added method `step` for reports

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

Added method `$.cached()`

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

Added method `$.doubleClick(options)`

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

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

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

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

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

Restored proxy after using `using`

Fixed `$.clear()` when element disappears

Released `selenide-appium:2.7.0`

Released `selenide-selenoid:2.3.6`

Renamed `master` branch to `main`

Truncate only `WebDriverException` messages

Fixed `$.download(FOLDER)` a bit

Fixed method `Selenide.download(url)`

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

Added method `$.press()`

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

Show `$.selectOption()` friendly in reports

Show `localStorage` friendly in reports

Select `<select>` options using JavaScript

Made `$.click(options)` chainable