Selenium-Webdriver Ruby --> How to wait for images to be fully loaded after click

Question

I am very new to Ruby and Selenium-Webdriver, so please, help :)

I am trying to open email campaign , sent to my inbox, that has images and take a screenshot in the

Answer 1

Ruby code from the docs (click on the 'ruby' button):

wait = Selenium::WebDriver::Wait.new(:timeout => 10) # seconds
begin
  element = wait.until { driver.find_element(:id => "some-dynamic-element") }
ensure
  driver.quit
end

Which works for me

Answer 2

You can use Implicit Wait and Explicit Wait to wait for a particular Web Element until it appears in the page. The wait period you can define and that is depends upon the application.

Explicit Wait:

An explicit waits is code you define to wait for a certain condition to occur before proceeding further in the code. If the condition achieved it will terminate the wait and proceed the further steps.

Code:

 WebDriverWait wait = new WebDriverWait(driver,30);
 wait.until(ExpectedConditions.visibilityOfElementLocated(By.id(strEdit)));

Or

 WebElement myDynamicElement = (new WebDriverWait(driver, 30))
 .until(new ExpectedCondition<WebElement>(){
@Override
public WebElement apply(WebDriver d) {
    return d.findElement(By.id("myDynamicElement"));
}});

This waits up to 30 seconds before throwing a TimeoutException or if it finds the element will return it in 0 - 30 seconds. WebDriverWait by default calls the ExpectedCondition every 500 milliseconds until it returns successfully. A successful return is for ExpectedCondition type is Boolean return true or not null return value for all other ExpectedCondition types.

You can use ExpectedConditions class as you need for the application.

Implicit Wait:

An implicit wait is to tell WebDriver to poll the DOM for a certain amount of time when trying to find an element or elements if they are not immediately available

Code:

 driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

One thing to keep in mind is that once the implicit wait is set - it will remain for the life of the WebDriver object instance

For more info use this link http://seleniumhq.org/docs/04_webdriver_advanced.jsp

The above code is in Java. Change as your language need.

Answer 3

To add to the above answer, here is how I use implicit and explicit wait in Ruby.

Implicit Wait

I pass this option to Selenium::WebDriver after initializing with a couple of lines like this:

browser = Selenium::WebDriver.for :firefox
browser.manage.timeouts.implicit_wait = 10

Just replace "10" with the number of seconds you'd like the browser to wait for page refreshes and other such events.

Explicit Wait

There are two steps to declaring an explicit wait in Selenium. First you set the timeout period by declaring a wait object, and then you invoke the wait with Selenium::Webdriver's .until method. It would look something like this, in your example:

wait = Selenium::WebDriver::Wait.new(:timeout => 10)
wait.until { browser.find_element(:xpath, "//path/to/picture").displayed? }

This would tell the Webdriver to wait a maximum of 10 seconds for the picture element to be displayed. You can also use .enabled? if the element you're waiting for is an interactive element - this is especially useful when you're working with Ajax-based input forms.

You can also declare an explicit wait period at the start of your script, and then reference the object again whenever you need it. There's no need to redeclare it unless you want to set a new timeout. Personally, I like to keep the wait.until wrapped in a method, because I know I'm going to reference it repeatedly. Something like:

def wait_for_element_present( how_long=5, how, what )
  wait_for_it = Selenium::WebDriver::Wait.new(:timeout => how_long )
  wait_for_it.until { @browser.find_element(how, what) }
end

(I find it's easier to just declare browser as an instance variable so that you don't have to pass it to the method each time, but that part's up to you, I guess?)

Answer 4

ExpectedConditions isn't supported yet in the Ruby Selenium bindings. This snippet below does the same thing as ExpectedConditions.elementToBeClickable — clickable just means "visible" and "enabled".

element = wait_for_clickable_element(:xpath => xpath)

def wait_for_clickable_element(locator)
  wait = Selenium::WebDriver::Wait.new(:timeout => 10)

  element = wait.until { @driver.find_element(locator) }
  wait.until { element.displayed? }
  wait.until { element.enabled? }

  return element
end