The default value of timeouts on selenium webdriver - selenium

I am interested in the default value of timeouts on selenium webdriver.
ImplicitlyWait, SetPageLoadTimeout and SetScriptTimeout.
Because I want to know, Do I need to set a values for those timeouts? or the default value is good for selenium webdriver working.
But I cannot find a correct answer, someone say the default value is 0, and other one say it is 30 sec.

These three timeouts are managed by the server-side of the Selenium equation. Your script, be it in Java, Python, Ruby, C#, or whatever, is a client that sends commands to a server that lives in the browser. (There may be an intermediary that relays commands to the browser, like Selenium grid. Unfortunately, it is also sometimes called a "server".)
The WebDriver specification, which was derived from Selenium has settled on the following values:
For implicit waits: 0 seconds. This means that if a selenium command does not find an element immediately, it reports immediately, rather than wait until an element is found.
For page loads: 300 seconds.
For script timeouts: 30 seconds.
(The specification gives the values in milliseconds. I've converted them to seconds for ease of reading.)
Selenium now follows the WebDriver specification.
In the past Selenium has used other values for these, however. For instance, the Firefox driver used to define its timeouts like this:
The implicit wait timeout is set to 0 by default. This means that if a command that finds elements does not find anything, it won't wait.
The page load timeout is set to -1 by default. This means that Selenium will wait indefinitely for the page to load.
What Saifur found is not the same as the page load timeout. That's a timeout between the Selenium client and the Selenium server, which is not particularly well explained on the page Saifur found.
The script timeout is set to 0 by default. A comment in the source code explains:
The amount of time, in milliseconds, this session should wait for asynchronous scripts to finish executing. If set to 0, then the timeout will not fire until the next event loop after the script is executed. This will give scripts that employ a 0-based setTimeout to finish.
So even if it set to zero, an asynchronous script can still execute but it has to complete before Selenium's timeout gets a chance to run again.
This is from the code that Selenium uses for Firefox. The other browsers use different code bases but they are supposed to behave consistently, at least with regards to things that are proper to Selenium itself, like these timeouts. So the values and their interpretations should be the same for other browsers too.

For implicit wait always default wait it ZERO. , you can check it here :
Selenium Webdriver diff. waits
And if you set custom time then web driver will wait to get element till that time and if element does not found till that time then only web driver will throw exception.

The Selenium documentation is very much unclear on these timeouts.
According to
this
the default timeout of the implicit-wait is 0
According to
this
any page that does not load in 60s will return http communication
timeout unless you explicitly overwrite the timeout.
Unfortunately, I did not find any reference to provide on
ScriptTimeout. But, it's defaults to 0 according to my knowledge
and experience. Will update you with any reference later

Related

How to wait until an object has been removed/deleted from a webpage in UFT?

In our web application there are tables where users can enter/delete data.
Checking once something has been added, I'd like UFT to wait until the element is no longer on the page before continuing. Each time a row, or element is deleted from the webpage the page refreshes, often UFT will try to continue thus causing the test to fail.
It seems .WaitProperty "visible", false, 3000 waits for the timeout to complete and then continues.
I'm looking for something similar to .StalenessOf in Selenium.
Looking to have the wait be more dynamic to make these tests run as fast as possible. If we end up using UFT I'll have a very large test suite and would like to reduce the amount of hard-coded waits, and avoid them if I could.
UFT supports Exist to check if an object exists.
You can pass a zero timeout and wait until the object doesn't exist.
While Obj.Exist(0)
Wait 1
WEnd

Protractor on top of my Selenium Code

I have my code written in Selenium for automating my application[Loading time of it varies] and it works fine when we use Thread.sleep for its loading time.I need to move out of thread.sleep as it is not ideal way of writing code,so i have tried to use all waits[implicit,explicit and fluent] given by Selenium.
In spite of that the script is not consistent and it is failing very often[mostly on element not found and stale element exception],so need to know since i have my all frameworks and code in Selenium is that any provision that i can import protractor jar file in it and use some lines of code in order to make my application to get synchronize with my script.
Your implicit wait is not gonna help , if your code works fine with Thread.sleep().
Thread.sleep(time) is an extreme case of Explicit wait.
An explicit wait is code you define to wait for a certain condition to occur before proceeding further in the code.
In Java selenium binding we can defined and use Explicit wait like this :
WebElement myDynamicElement = (new WebDriverWait(driver, 10))
.until(ExpectedConditions.presenceOfElementLocated(By.id("myDynamicElement")));
This waits up to 10 seconds before throwing a TimeoutException or if it finds the element will return it in 0 - 10 seconds. WebDriverWait by default calls the ExpectedCondition every 500 milliseconds until it returns successfully.
Note that : Do not mix implicit and explicit waits. Doing so can cause unpredictable wait times.
Question : mostly on element not found and stale element exception occurs?
Just verify your locators. Locators should be static not dynamic. Just for example you should never use dynamic ID of any web element which is generated by JS or any other programming language.
Using protractor, you can't just sync your script. All you can do now is to make changes to your locator and waiting time.
Hope this will help you.
It is not possible to use protractor into Selenium, but you can rewrite all tests into protractor and you will inherit all from selenium. Protractor is wrapper for Webdriverjs so you get each and every faeture of webdriverjs in protractor + protractor's own feature of locators and asynchronous waits.

a wait that stops the test till nothing is happening in the web page anymore

I am using Java and Selenium to write a test. Many times in my test i have to wait till the page or some part of it loads something. I want to wait till the load is finished. I found these two:
1) pageLoadTimeout
2) setScriptTimeout
But I don't know the exact difference between them or even if they are what I need.
The document says:
setScriptTimeout: Sets the amount of time to wait for an asynchronous script to finish execution before throwing an error. If the timeout is negative, then the script will be allowed to run indefinitely.
and
pageLoadTimeout: Sets the amount of time to wait for a page load to complete before throwing an error. If the timeout is negative, page loads can be indefinite.
but I don't really get it.
what I need is a wait that stops the test till nothing is happening in the web page anymore.
Define "nothing is happening in the web page." Now define it in such a way that will satisfy every web page ever created, or that ever will be created. Did your definition include that no more network traffic is coming over the wire? Did your definition include that the onload event has fired? How about document.readyState returning a value meaning "complete?" Did you take JavaScript execution into account? How about JavaScript scheduled using window.setTimeout()? WebSockets? Service Workers? What about <frame> or <iframe> elements?
Now you know why WebDriver doesn't have a "wait for page complete" type of wait. The items mentioned above don't even begin to scratch the surface of the list of things a user could legitimately use in a definition of "nothing is happening on the page anymore." The correct approach would be to wait for the element you want to interact with on the next page to be available in the DOM. The WebDriverWait class is ideally suited for exactly this.

How to manage time in selenium script to execute same script on different server

I'm automating functionality of My web project . I've created one test suit using selenium Webdriver which is working fine on Local Server(created on same). But while I do execute the same on Azure server(obviously slow as compared to local environment), The script get failed and I need to debug the whole script and need to put some wait where its taking time to locate the element. And after all changes on azure server some time it failed on local server too.
How to deal with slow website response ?
Is there any effective way of scripting which required less effort to execute the script on different environment ?
You can set Implicit wait (less desired) or Explicit waits.
var driver = new ChromeDriver();
driver.Manage().Timeouts().ImplicitlyWait(TimeSpan.FromSeconds(1000));
driver.FindElement(By.XPath("your xpath")).Click();
In this case, you're 'telling' Selenium to wait the specified timeout before it will search the element you want to be found. If the element was not found, you will get the Timeout error.
var driver = new ChromeDriver();
driver.FindElement(By.XPath("your xpath")).Click();
In this case you're telling Selenium to get the element automatically, so in case it will not be found, you will get a NoSuchElementException, with no timeouts because there's no time to wait before the element to be present.
And if we're expanding it to the Explicit wait:
var driver = new ChromeDriver();
var wait = new WebDriverWait(driver, new TimeSpan(0, 0, 1000));
wait.Until(d => d.FindElement(By.XPath("your xpath"))).Click();
In this case you're telling Selenium to keep searching for the element until it is found but no longer than the maximum timeout specified as a param to WebDriverWait.
Let's take for example the case where on your local environment a page loads on 1 minute and on Azure it takes 10 minutes (far stretched example), if you're going ahead with the Explicit wait, then you could set the timeout to let's say 11 minutes.
Those 11 minutes are the maximum timeout in which Selenium is polling for a specific element to be found. However, if you run your tests on the local environment and the element is found in 30 seconds, then your test will continue with the execution. It will not wait for the maximum timeout to complete before doing that.
It's most likely not time to locate the element, it's probably the speed of pages loading. Use WebDriverWaits for page transitions and any dynamic page changes. Once you wait for an element or dynamic section of the page to load, you can interact with the page without having to worry about speed. That will probably take care of most of your issues but without more specifics, it's hard to say what else might be going on.

What is SetScriptTimeout-Webdriver

when SetScriptTimeout should be used and please provide me any example.
I know the defn
Sets the amount of time to wait for an asynchronous script to finish execution before throwing an error. If the timeout is negative, then the script will be allowed to run indefinitely.
but not sure what it does exactly.
You've got two answers already, neither of which I find explain clearly the point of setting a script timeout.
First, it is important the script timeout affects only JavaScript code executed with executeAsyncScript and nothing else. In particular, executeScript is not affected by it.
So why do you want to set a timeout for executeAsyncScript? Chandan Nayak correctly explained that the default timeout is 0s so you have to change this timeout if you want to use executeAsyncScript with asynchronous scripts that actually perform some work. But why not just set it to -1 and be done with it? After all, if you set it to -1 then you turn off the timeout. So you won't get any timeouts anymore. Mission accomplished, right? Nope.
What you want to do is set the timeout to a value that allows the code you use with executeAsyncScript to perform it works while at the same time detect when a script has gone rogue. For instance, if from experience you know that a script you pass to executeAsyncScript is going to be done in 2 seconds or less (except perhaps in extremely unusual circumstances), then you set the timeout to 2 seconds so that if there is a bug somewhere and the code never terminates, you get a timeout after 2 seconds. Otherwise, Selenium will happily wait forever for the script to complete.
From WebDriver documentation:
setScriptTimeout(long time, java.util.concurrent.TimeUnit unit)
Sets the amount of time to wait for an asynchronous script to finish execution before throwing an error. This works only for Assync scripts (executeAsyncScript)
Let's run a simple javascript: (Do not set setScriptTimeout ) - Now this shall execute without throwing any issue.
((JavascriptExecutor) driver).executeScript("alert('hello world');");
Lets run a simple Assync Script: ( Do not set setScriptTimeout) - This shall fail with error - "Timed out waiting for async script result after 0ms"
((JavascriptExecutor) driver).executeAsyncScript("window.setTimeout(arguments[arguments.length - 1], 500);");
To resolve the issue: setScriptTimeout to 1 Second:
driver.manage().timeouts().setScriptTimeout(1, TimeUnit.SECONDS);
And then run the same Assync Script mentioned above and it shall execute without any error.
Reason:
The default timeout for a script to be executed is 0ms. In most cases, including the examples below, one must set the script timeout WebDriver.Timeouts.setScriptTimeout(long, java.util.concurrent.TimeUnit) beforehand to a value sufficiently large enough
More Reference Links:
When should setScriptTimeout be used?
WebDriver executeAsyncScript vs executeScript
WebDriver Doc
Web application automation is dependent on many factors like browser, network speed, embedded scripting etc. To write robust code for running in all environments we need to inserts wait for WebElements before performing any operation on that.
WebDriver wait (synchronization) can be obtained either by using support.ui or driver().manage().timeouts()
If we use driver.manage().timeouts(), a common practice to achieve synchronization is to use JavaScript via JavascriptExecutor which in turn provide two methods for script execution:
executeAsyncScript -> This method doesn't block the execution of next line of code...till execution of this method is completed. This method will execute as well as next line of code will be executed...asynchronously. (without blocking each other)
executeScript -> This method will block the execution till it's execution is completed and then it moves to next line of code. In short your automation code will halt till the Javascript is executed via this method.
Now since executeAsyncScript method doesn't block the execution of next line of code, it might be beneficial to use driver.manage().timeouts().setScriptTimeout(30,SECONDS);
so that our code can wait for specified amount of time for an asynchronous script to finish execution before throwing an error.