How to use isDisplayed method of org.openqa.selenium.remote.RemoteWebElement class

The problem are not duplicate classes but the way generics are used. Here is a little MCVE replicating the situation in Appium's WebDriver class:

package de.scrum_master.stackoverflow;

public interface WebElement {}

package de.scrum_master.stackoverflow;

public interface WebDriver {
  <T extends WebElement> T findElement();
}

package de.scrum_master.stackoverflow;

public class Application {
  static WebDriver webDriver;

  static void myOverloadedMethod(String text) {}
  static void myOverloadedMethod(WebElement text) {}

  public static void main(String[] args) {
    // These 3 variants work
    myOverloadedMethod("test");
    myOverloadedMethod((WebElement) webDriver.findElement());
    WebElement webElement = webDriver.findElement();
    myOverloadedMethod(webElement);

    // This one does not work
    myOverloadedMethod(webDriver.findElement());
  }
}

Explanation: Due to type erasure doSomething's generic return type <T extends WebElement> evaluates to Object, so when trying to use that result for calling myOverloadedMethod(..) the compiler does not know which method to select.

Solution: You need to help by casting or explicitly declaring a type for a variable containing the method parameter.

P.S.: If you would modify the interface definition from interface WebDriver to interface WebDriver<T>, the compilation error would go away. But Appium's implementation does not do that, maybe because they want to stay as compatible(?) as possible to the original Selenium class. You have to ask them.

Update: Because the OP seems to have problems understanding my answer or to believe I did not try his sample code, which of course I used to reproduce and understand his problem:

package de.scrum_master.appium;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;

public class Interactions {
  public static void touchWebElement(WebElement element, WebDriver driver) {}

  public static void touchWebElement(By by, WebDriver driver) {
    // Works
    WebElement webElement = driver.findElement(by);
    touchWebElement(webElement, driver);
    // Works
    touchWebElement((WebElement) driver.findElement(by), driver);
    // Ambiguous due to type erasure -> does not work
    touchWebElement(driver.findElement(by), driver);
  }
}

There is absolutely no need rename methods, re-package any classes or perform other types of Maven/Gradle stunts here.

Besides the correct Qwerky's answer, you can also do simple

driver.findElement(By.xpath("//select/option[@value='1']")).click();

This finds the option element with value='1' and clicks it, practically selecting it in the drop-down.

Both mine and Qwerky's solution are described and explained here, in the documentation.

First the update ¹

execute_cdp_cmd(): With the availability of execute_cdp_cmd(cmd, cmd_args) command now you can easily execute google-chrome-devtools commands using Selenium. Using this feature you can modify the navigator.webdriver easily to prevent Selenium from getting detected.

Preventing Detection ²

To prevent Selenium driven WebDriver getting detected a niche approach would include either / all of the below mentioned steps:

• Adding the argument --disable-blink-features=AutomationControlled

  from selenium import webdriver
  
  options = webdriver.ChromeOptions() 
  options.add_argument('--disable-blink-features=AutomationControlled')
  driver = webdriver.Chrome(options=options, executable_path=r'C:\WebDrivers\chromedriver.exe')
  driver.get("https://www.website.com")
  

You can find a relevant detailed discussion in Selenium can't open a second page

• Rotating the user-agent through execute_cdp_cmd() command as follows:

  #Setting up Chrome/83.0.4103.53 as useragent
  driver.execute_cdp_cmd('Network.setUserAgentOverride', {"userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.53 Safari/537.36'})
  

• Change the property value of the navigator for webdriver to undefined

  driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
  

• Exclude the collection of enable-automation switches

  options.add_experimental_option("excludeSwitches", ["enable-automation"])
  

• Turn-off useAutomationExtension

  options.add_experimental_option('useAutomationExtension', False)
  

Sample Code ³

Clubbing up all the steps mentioned above and effective code block will be:

from selenium import webdriver

options = webdriver.ChromeOptions() 
options.add_argument("start-maximized")
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
driver = webdriver.Chrome(options=options, executable_path=r'C:\WebDrivers\chromedriver.exe')
driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
driver.execute_cdp_cmd('Network.setUserAgentOverride', {"userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.53 Safari/537.36'})
print(driver.execute_script("return navigator.userAgent;"))
driver.get('https://www.httpbin.org/headers')

History

As per the W3C Editor's Draft the current implementation strictly mentions:

The webdriver-active flag is set to true when the user agent is under remote control which is initially set to false.

Further,

Navigator includes NavigatorAutomationInformation;

It is to be noted that:

The NavigatorAutomationInformation interface should not be exposed on WorkerNavigator.

The NavigatorAutomationInformation interface is defined as:

interface mixin NavigatorAutomationInformation {
    readonly attribute boolean webdriver;
};

which returns true if webdriver-active flag is set, false otherwise.

Finally, the navigator.webdriver defines a standard way for co-operating user agents to inform the document that it is controlled by WebDriver, so that alternate code paths can be triggered during automation.

Caution: Altering/tweaking the above mentioned parameters may block the navigation and get the WebDriver instance detected.

Update (6-Nov-2019)

As of the current implementation an ideal way to access a web page without getting detected would be to use the ChromeOptions() class to add a couple of arguments to:

• Exclude the collection of enable-automation switches
• Turn-off useAutomationExtension

through an instance of ChromeOptions as follows:

• Java Example:

  System.setProperty("webdriver.chrome.driver", "C:\\Utility\\BrowserDrivers\\chromedriver.exe");
  ChromeOptions options = new ChromeOptions();
  options.setExperimentalOption("excludeSwitches", Collections.singletonList("enable-automation"));
  options.setExperimentalOption("useAutomationExtension", false);
  WebDriver driver =  new ChromeDriver(options);
  driver.get("https://www.google.com/");
  

• Python Example

  from selenium import webdriver
  
  options = webdriver.ChromeOptions()
  options.add_experimental_option("excludeSwitches", ["enable-automation"])
  options.add_experimental_option('useAutomationExtension', False)
  driver = webdriver.Chrome(options=options, executable_path=r'C:\path\to\chromedriver.exe')
  driver.get("https://www.google.com/")
  

• Ruby Example

    options = Selenium::WebDriver::Chrome::Options.new
    options.add_argument("--disable-blink-features=AutomationControlled")
    driver = Selenium::WebDriver.for :chrome, options: options
  

Legends

¹: Applies to Selenium's Python clients only.

²: Applies to Selenium's Python clients only.

³: Applies to Selenium's Python clients only.

I think the idea is for you to use JUnit's Assert.assertXXX() the difference is that verifyXXX will fail during teardown instead of immediately but I think with Selenium tests you usually want to fail as fast as possible (since those tests tend to be slow).

I believe you have several options:

Either specify the folder (in which your Firefox binary is) in your PATH system variable - here's how.

Or call

WebDriver driver = new FirefoxDriver(new FirefoxBinary(new File("path/to/your/firefox.exe")), profile);

The problem was with my IE settings. The problem was resolved when the security settings in IE was changed to "Enable Protected Mode" for "Internet", "Local Intranet", "Trusted Sites" and "Restricted Sites". You can change it by going to Internet Options security tab and enable check box "Enable Protected Mode" for all the zones. I was able to get these information from the link http://jimevansmusic.blogspot.in/2012/08/youre-doing-it-wrong-protected-mode-and.html

Try element.getAttribute("value")

The text property is for text within the tags of an element. For input elements, the displayed text is not wrapped by the <input> tag, instead it's inside the value attribute.

Note: Case matters. If you specify "Value", you'll get a 'null' value back. This is true for C# at least.

different dialogs handling using selenium webDriver:

import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class JavaScriptAlertTest {

public static void main(String[] args) {

    WebDriver myTestDriver = new FirefoxDriver();
    myTestDriver.get("...blablabla....");

    myTestDriver.manage().window().maximize();

    myTestDriver.findElement(By.xpath("//input[@value = 'alert']")).click();

    Alert javascriptAlert = myTestDriver.switchTo().alert();
    System.out.println(javascriptAlert.getText()); // Get text on alert box
    javascriptAlert.accept();

    System.out.println("*************prompt******************************************");

    myTestDriver.findElement(By.xpath("//input[@value = 'prompt']")).click();

    Alert javascriptprompt = myTestDriver.switchTo().alert();
    javascriptprompt.sendKeys("This is Selenium Training");

    System.out.println(javascriptprompt.getText()); // Get text on alert box

    javascriptprompt.accept();
    javascriptprompt = myTestDriver.switchTo().alert();

    System.out.println(javascriptprompt.getText()); // Get text on alert box
    javascriptprompt.accept();

    myTestDriver.findElement(By.xpath("//input[@value = 'prompt']")).click();

    javascriptprompt = myTestDriver.switchTo().alert();

    System.out.println(javascriptprompt.getText()); // Get text on alert box

    javascriptprompt.dismiss();
    javascriptprompt = myTestDriver.switchTo().alert();

    System.out.println(javascriptprompt.getText()); // Get text on alert box
    javascriptprompt.accept();

    System.out.println("***********************************confirm dialog box****************************");
    myTestDriver.findElement(By.xpath("//input[@value = 'confirm']")).click();

    Alert javascriptconfirm = myTestDriver.switchTo().alert();
    javascriptconfirm.accept();

    javascriptconfirm = myTestDriver.switchTo().alert();
    System.out.println(javascriptconfirm.getText()); // Get text on alert box
    javascriptconfirm.accept();

    myTestDriver.findElement(By.xpath("//input[@value = 'confirm']")).click();
    javascriptconfirm = myTestDriver.switchTo().alert();

    javascriptconfirm.dismiss();
    javascriptconfirm = myTestDriver.switchTo().alert();
    System.out.println(javascriptconfirm.getText()); // Get text on alert box
    javascriptconfirm.accept();

}
}

Hope it helps you:)

You can locate an element that loads after the initial page loads and then make Selenium wait until that element is found.

WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("ID")));