How to use getFlagObjects method of org.openqa.selenium.grid.commands.Hub class

You can try the following code:

// wait for the window to appear
WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.alertIsPresent());

// switch to the file upload window
Alert alert = driver.switchTo().alert();

// enter the filename
alert.sendKeys(fileName);

// hit enter
Robot r = new Robot();
r.keyPress(KeyEvent.VK_ENTER);
r.keyRelease(KeyEvent.VK_ENTER);

// switch back
driver.switchTo().activeElement();

That's downright easy: //div[label[text()='Last Name']]/span[@class='metadataField metadataFieldReadonly']/input - literally, "the input contained in the span with the metadataField and metadataFieldReadonly classes contained in the div that contains the label with the text 'Last Name'". So you're using the label to locate the div and then building from it to the input you want.

To be a more robust, you shouldn't count on the ordering of the class names - that isn't guaranteed by the specs. So something like this would be stronger: //div[label[text()='Last Name']]/span[contains(concat(' ', @class,' '),' metadataField ') and contains(concat(' ',@class,' '),' metadataFieldReadonly ')]/input.

#getText()

getText() delivers the innerText of a WebElement.

Your input field does not have any inner Text. The text is found inside your value-attribute, hence accessing it via getAttribute("value") is the correct way to do it.

Your all xpath are looks OK, Just some syntactically incorrect. you are missing // in your xpath

The correct xpath are as below :-

By by = By.xpath("//span[.='Settings']")

Or

By by = By.xpath("//span[text()='Settings']")

Or

By by = By.xpath("//div[@class='settings-padding']/span"))

Or you can use cssSelector as :-

By by = By.cssSelector("div.settings-padding > span"))

Using anyone of the above By locator you can locate element as below :-

WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement el = wait.until(presenceOfElementLocated(by));

Hope it helps...:)

WebDriver is an interface.

FirefoxDriver is the implementation.

To understand better, please do read docs on Java Interface.

    psdbComponent.clickDocumentLink();
    ArrayList<String> tabs2 = new ArrayList<String> (driver.getWindowHandles());
    driver.switchTo().window(tabs2.get(1));
    driver.close();
    driver.switchTo().window(tabs2.get(0));

This code perfectly worked for me. Try it out. You always need to switch your driver to new tab, before you want to do something on new tab.

TL;DR: Always use explicit wait. Forget that implicit wait exists.

---

Here is a quick rundown on the differences between explicit and implicit wait:

Explicit wait:

• documented and defined behaviour.
• runs in the local part of selenium (in the language of your code).
• works on any condition you can think of.
• returns either success or timeout error.
• can define absence of element as success condition.
• can customize delay between retries and exceptions to ignore.

Implicit wait:

• undocumented and practically undefined behaviour.
• runs in the remote part of selenium (the part controlling the browser).
• only works on find element(s) methods.
• returns either element found or (after timeout) not found.
• if checking for absence of element must always wait until timeout.
• cannot be customized other than global timeout.

---

Code examples with explanation. First implicit wait:

WebDriver driver = new FirefoxDriver();
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
driver.get("http://somedomain/url_that_delays_loading");
WebElement myDynamicElement = driver.findElement(By.id("myDynamicElement"));

Now explicit wait:

WebDriver driver = new FirefoxDriver();
driver.get("http://somedomain/url_that_delays_loading");
WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement myDynamicElement = wait.until(
  ExpectedConditions.presenceOfElementLocated(By.id("myDynamicElement")));

Both code examples do the same thing. Find a certain element and give up if not found after 10 seconds. The implicit wait can do only this. It can only try to find an element with a timeout. The strength of explicit wait is that it can wait for all kinds of conditions. Also customize timeout and ignore certain exceptions.

Example of possible conditions: elementToBeClickable, numberOfElementsToBeMoreThan or invisibilityOf. Here is a list of the built in expected conditions: https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html

More explanations:

The implicit wait timeout has effect only on findElement* methods. If set then all findElement* will "wait" for the set time before declaring that the element cannot be found.

How a findElement* will wait is not defined. It depends on browser or operating system or version of selenium. Possible implementations are:

• repeatedly try to find element until timeout. return as soon as element is found.
• try to find element. wait until timeout. try again.
• wait until timeout. try to find element.

This list is gathered from observations and reading bug reports and cursory reading of selenium source code.

---

My conclusion: Implicit wait is bad. The capabilities are limited. The behaviour is undocumented and implementation dependent.

Explicit wait can do everything implicit wait can and more. The only disadvantage of explicit wait is a bit more verbose code. But that verbosity makes the code explicit. And explicit is better that implicit. Right?

---

Further reading:

• Official documentation (does not really explain the problematic other than warning from mixing implicit and explicit wait).
• Answer on a related question from Jim Evans. Jim Evans is a maintainer of selenium. Summary: don't mix implicit and explicit wait.
• Two blog posts explaining implicit and explicit wait in great detail:
  • http://vnrtech.blogspot.de/2013/04/selenium-implicit-wait.html
  • http://vnrtech.blogspot.de/2013/04/selenium-explicit-wait.html
• Selected bugs about implicit and explicit wait in selenium:
  • http://code.google.com/p/selenium/issues/detail?id=2934
  • http://code.google.com/p/selenium/issues/detail?id=4471
  • http://code.google.com/p/selenium/issues/detail?id=7972
• Code
  • explicit wait
  • implicit wait
• What Happens When We Mix Implicit Wait And Explicit Wait
• How to create custom expected conditions in Selenium

I got this solution which is working well for all three browser(Firefox, Chrome and IE).

from selenium import webdriver
import time
import win32com.client

driver=webdriver.Firefox()
driver.maximize_window()
driver.get('https://www.engprod-charter.net/')
shell = win32com.client.Dispatch("WScript.Shell")   
shell.Sendkeys("username")  
time.sleep(2)
shell.Sendkeys("{TAB}")
time.sleep(2)
shell.Sendkeys("password") 
time.sleep(2)
shell.Sendkeys("{ENTER}")
time.sleep(2)
driver.quit()

Note : Install win32com.client if you have not downloaded. To install win32com.client use below command

pip install pypiwin32

It is actually possible to scroll automatically to element. Although this is not a good solution in this case (there must be a way to get it working without scrolling) I will post it as a workaround. I hope someone will come up with better idea...

public void scrollAndClick(By by)
{
   WebElement element = driver.findElement(by);
   int elementPosition = element.getLocation().getY();
   String js = String.format("window.scroll(0, %s)", elementPosition);
   ((JavascriptExecutor)driver).executeScript(js);
   element.click();
}