How to use InvalidCoordinatesException class of org.openqa.selenium.interactions package

I figured out the answer.

• Start Sauce Connect, and pass proxy server information

  java -jar Sauce-Connect.jar myname xxxxxx -p localhost:9091
  

  Running the above command will pass all requests to localhost 9091 port, and you may use netcat to confirm.

  nc -l 9091
  

• Run Java Client

  ProxyServer proxyServer = new ProxyServer(9091);
  proxyServer.start();    
  
  Proxy proxy = proxyServer.seleniumProxy();
  DesiredCapabilities capabilities = DesiredCapabilities.firefox();
  // DO NOT set proxy for RemoteWebDriver
  // capabilities.setCapability(CapabilityType.PROXY, proxy);
  capabilities.setCapability("version", "5");
  capabilities.setCapability("platform", Platform.XP);
  this.driver = new RemoteWebDriver(
          new URL("http://myname:xxxxxx@ondemand.saucelabs.com:80/wd/hub"),
          capabillities);
  

  The Java Client should starts a proxy at Port 9091. Unlike using FirefoxDriver directly, proxy should not be set in capabilities.

I found the work around as below

1. Open terminal
2. Navigate to path where your chromedriver file is located
3. Execute any one of the below commands

Command1: xattr -d com.apple.quarantine <name-of-executable>

Example

/usr/local/Caskroom/chromedriver 
$ xattr -d com.apple.quarantine chromedriver 

(or)

Command2: spctl --add --label 'Approved' <name-of-executable>

Source: https://docwhat.org/upgrading-to-catalina

Note: This will work only with the file(s) where the above command is executed. If a new chromedriver is downloaded then the command has to be executed again on the newly downloaded file

So apparantly this is not possible with BrowserMob out of the box. I therefore wrote a proxy extension SeleniumSslProxy that can be plugged into Selenium and adds certificate based authentication to create a HTTPS connection.

This is how it works:

• intercept Selenium HTTP requests with BrowserMob
• setup an SSLContext given a certificate (.pfx file) and password
• use okhttp to forward the request to the target URL
• convert the okhttp Response to a netty FullHttpResponse so it can be handled by Selenium

You can find the code on github. Here's an example how it can be used in Selenium end-to-end tests (also works in headless mode):

@Before
public void setup() {
    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
    File clientSslCertificate = new File(
        classLoader.getResource("certificates/some-certificate.pfx").getFile());
    String certificatePassword = "superSecret";

    this.proxy = new SeleniumSslProxy(clientSslCertificate, certificatePassword);
    this.proxy.start();

    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setProxy(proxy);
    this.webDriver = new ChromeDriver(chromeOptions);
}

@Test
public void pageTitleIsFoo() {
    // given
    String url = "http://myurl.lol";
    // NOTE: do not use https in the URL here. It will be converted to https by the proxy.

    // when
    this.webDriver.get(url);
    this.webDriver.manage().timeouts().implicitlyWait(5, SECONDS);

    // then
    WebElement title = this.webDriver.findElement(By.className("title"));
    assertEquals("Foo", title.getText());
}

@After
public void teardown() {
    this.webDriver.quit();
    this.proxy.stop();
}

Note that I only used chromeDriver and never tested it with other drivers. Minor adjustments to the SeleniumSslProxy might be necessary to be used with other drivers.

DesiredCapabilities would help you to change user agent.

You can achieve this by calling these methods:

• setBrowserName(java.lang.String browserName)
• setPlatform(Platform platform)
• setVersion(java.lang.String version)

Or

• static DesiredCapabilities chrome()
• static DesiredCapabilities firefox()
• static DesiredCapabilities iphone()
• ...

More here.

As we know Selenium interacts with browsers and these get methods will retrieve info related to browsers only. As explained in other answers very clearly, screen resolution and browser are different. The simple example below shows very clearly that the web driver is getting only the browser's dimensions.

    WebDriver driver=new FirefoxDriver();
    driver.get("http://www.google.com");
    System.out.println(driver.manage().window().getSize()); //output: (994, 718)

    driver.manage().window().maximize();
    System.out.println(driver.manage().window().getSize()); //output: (1382, 744)

You can use or expected conditions for that

WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.or(
    ExpectedConditions.visibilityOfElementLocated(By.id("id1")),
    ExpectedConditions.visibilityOfElementLocated(By.id("id2"))
));

Or use cssSelector or ,

wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("#id1, #id2"));

Just the other day i've answered something similar to this so it's still fresh. The reason your code is failing is if the alert is not shown by the time the code is processed it will mostly fail.

Thankfully, the guys from Selenium WebDriver have a wait already implemented for it. For your code is as simple as doing this:

String alertText = "";
WebDriverWait wait = new WebDriverWait(driver, 5);
// This will wait for a maximum of 5 seconds, everytime wait is used

driver.findElement(By.xpath("//button[text() = \"Edit\"]")).click();//causes page to alert() something

wait.until(ExpectedConditions.alertIsPresent());
// Before you try to switch to the so given alert, he needs to be present.

Alert alert = driver.switchTo().alert();
alertText = alert.getText();
alert.accept();

return alertText;

You can find all the API from ExpectedConditions here, and if you want the code behind this method here.

This code also solves the problem because you can't return alert.getText() after closing the alert, so i store in a variable for you.

elementToBeClickable is used for checking an element is visible and enabled such that you can click it.

ExpectedConditions.elementToBeClickable returns WebElement if expected condition is true otherwise it will throw TimeoutException, It never returns null.

So if your using ExpectedConditions.elementToBeClickable to find an element which will always gives you the clickable element, so no need to check for null condition, you should try as below :-

WebDriverWait wait = new WebDriverWait(Scenario1Test.driver, 10); 
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.xpath("(//div[@id='brandSlider']/div[1]/div/div/div/img)[50]")));
element.click();

As you are saying element.click() passes both on link and label that's doesn't mean element is not clickable, it means returned element clicked but may be there is no event performs on element by click action.

Note:- I'm suggesting you always try first to find elements by id, name, className and other locator. if you faced some difficulty to find then use cssSelector and always give last priority to xpath locator because it is slower than other locator to locate an element.

Hope it helps you..:)

Use .getOptions() method and store them in a list .Then find its size.

Select se = new Select(driver.findElement(By.id("select drop down locator")));

List<WebElement> l = se.getOptions();
l.size();

-Ajay