Once of the biggest issues I see with people new to Selenium ( or any number of the other web automation tools ) is the liberal scattering of Thread.sleep(xxx) through out the code. This should be considered a bad smell introducing timing specific code into your script.

What happens if UI apps runs differently on different machines, or OS’s or internet links ( Broadband, Moble, T1 etc ). Do you have variable timing statements ?

These sleep() statements start to creep into code when a page doesn’t behave how the automation tester thinks it should. Each browser has different HTML and CSS rendering engine and each render the DOM ( Document Object Model ) in different ways to get the same result ( well apart from IE which is just pants ).

The person writing the script will pop in a sleep () when a specific element doesn’t appear when they expect it to, but there are a couple of patterns that make the sleep statement almost redundant

Wait For Page To Load
The first thing to do when you click on any link or open any new URL is wait for the htmnl page to load. This by the way is not what you think. It does not wait for the page to be displayed on the screen. Instead it waits for the entire HTML object to be loaded. In essence it is waiting for the DOM processing engine to reach and which point the document is loaded. This simple step will get quite a few of the needs for sleep () calls

Actively Wait For Element
Rather than put a random sleep() before an action activity like clickLink () or type () function call, I always wrap these calls with a waitForElementPresent() or waitForElementVisible (). The reason for this is that the script will fail with a proper exception. I typically have a class of functions ( in this instance Java ) which do this, e.g

protected boolean waitForElementEnabled(final String locator, final long timeout) {
long timeNow = System.currentTimeMillis();
while(System.currentTimeMillis() < (timeNow+timeout)) {
String eval = selenium.getEval("this.browserbot.findElement('"+locator+"').disabled");
if(!eval.equalsIgnoreCase("true")) {
return true;
}
try {
Thread.sleep(Config.wait_pause);
} catch (InterruptedException e) {
return false;
}
}
return false;
}

protected boolean waitForElementPresent(final String locator) {
for(int c = 0; c if( selenium.isElementPresent(locator)) {
return true;
}
try {
Thread.sleep(Config.wait_pause);
} catch (InterruptedException e) {
return false;
}
}
return false;
}

protected boolean waitForTextPresent (final String text) {
for(int c = 0; c if(selenium.isTextPresent(text)) {
return true;
} else {
if ( !sleep () ) {
return false;
}
}
}
return false;
}

protected boolean waitForValuePresent (final String locator, final String text) {
for(int c = 0; c String found = selenium.getValue(locator);
if( found!=null&&found.equals(text)) {
return true;
} else {
if ( !sleep () ) {
return false;
}
}
}
return false;
}

protected boolean waitForAnyValuePresent (final String locator) {
for(int c = 0; c String found = selenium.getValue(locator);
if( found!=null&&found.length()>0) {
return true;
} else {
if ( !sleep () ) {
return false;
}
}
}
return false;
}

If I am using JUnit then I can wrap this calls around an assertTrue call

assertTrue(this.waitForElementPresent(“id=login”));
click(“id=login”);

The only time I end up using a sleep is with Ajax. For example a developer may pop up a “Processing….” dialog or spinner when Ajax activity is happening, but to stop the screen flashing they might put a timer on so that the box only appears if the Ajax call is taking 30 msecs or more, if it doesn’t then the box never appears. So in this instance I would sleep for 35 msecs and then see if the box is there, if it is wait for it to close, if its not there assume the Ajax call has happened and the script moves on.