How to use getMethod method of org.openqa.selenium.remote.http.HttpRequest class

"Remote Debugging Port" was the solution for my problem.

1. I added the "remote-debugging-port=XXXX" to my CEF (Chromium Embedded Framework) command: https://blog.chromium.org/2011/05/remote-debugging-with-chrome-developer.html This allowed me to see and manage my app's CEF windows through localhost:XXXX.

2. I used both Winium and Selenium to test my app. Winium for all my WPF windows and selenium for all my CEF windows. My GUI test starts with Winium Driver to open my app and navigate WPF windows. Each time I need to debug a CEF window, I'm opening a Chrome Driver using selenium with the "remote-debugging-port" argument, which allows me to click elements inside that window. When I'm finish with this chromium window I'm closing the selenium driver and continues with Winium.

Use Selenium and Winium with IntelliJ IDEA

Selenium is a portable framework for testing and automating web applications. Winium is a Selenium-based tool for testing and automating desktop applications on Windows. In order to use these modules inside IntelliJ IDEA project, follow these steps:

1. Download selenium-server-standalone jar file (e.g. selenium-server-standalone-3.141.59.jar) https://www.seleniumhq.org/download/
2. Download winium-webdriver jar file (e.g. winium-webdriver-0.1.0-1.jar) http://central.maven.org/maven2/com/github/2gis/winium/winium-webdriver/0.1.0-1/
3. Add both jars to your project structure: File → Project Structure → Dependencies → +

4. Now all Selenium and Winium imports should work. For example:

   import org.openqa.selenium.By;
   import org.openqa.selenium.WebDriver;
   import org.openqa.selenium.chrome.ChromeDriver;
   import org.openqa.selenium.chrome.ChromeOptions;
   import org.openqa.selenium.support.ui.ExpectedConditions;
   import org.openqa.selenium.support.ui.WebDriverWait;
   import org.openqa.selenium.winium.DesktopOptions;
   import org.openqa.selenium.winium.WiniumDriver;
   import org.openqa.selenium.winium.WiniumDriverService;
   

Use ChromeDriver with Selenium

Follow these steps:

1. Install the Java JDK and add its bin directory to your system PATH variable.
2. Create a directory that will contain all files. This tutorial uses c:\temp.
3. Download ChromeDriver and extract it (e.g. chromedriver_win32.zip provides chomedriver.exe) https://sites.google.com/a/chromium.org/chromedriver/downloads
4. Download selenium-server-standalone-X.X.X-alpha-1.zip (e.g. selenium-server-standalone-4.0.0-alpha-1.zip) http://selenium-release.storage.googleapis.com/index.html
5. Download a CEF binary distribution client from Cefbuilds and extract (e.g. cef_binary_76.1.13+gf19c584+chromium-76.0.3809.132_windows64.tar.bz2) http://opensource.spotify.com/cefbuilds/index.html
6. Your directory structure should now look similar to this:

c:\temp\
  cef_binary_3.2171.1979_windows32_client\
    Release\
      cefclient.exe  (and other files)
  chromedriver.exe
  Example.java
  selenium-server-standalone-2.44.0.jar

For more information you can read this wiki: https://bitbucket.org/chromiumembedded/cef/wiki/UsingChromeDriver.md

Use WiniumDriver with Winium

Follow these steps:

1. Download the Winium.Desktop.Driver.zip and extract it to c:\temp https://github.com/2gis/Winium.Desktop/releases

Java Code Example

Start a winium driver and open your app:

DesktopOptions desktopOption = new DesktopOptions();
desktopOption.setApplicationPath("Path_to_your_app.exe");
File drivePath = new File("C:\\temp\\Winium.Desktop.Driver.exe");
WiniumDriverService service = new WiniumDriverService.Builder().usingDriverExecutable(drivePath).usingPort(9999).withVerbose(true).withSilent(false).buildDesktopService();
service.start();
WiniumDriver winiumDriver = WiniumDriver(service, desktopOption);

Navigate and test WPF windows using winium. For example:

winiumDriver.findElement(By.id("someElementID")).click();

Create a ChromeOptions object which holds all needed selenium information such as chromium client and remote debugging port. Make sure to change the "XXXX" port to your remote debugging port.

System.setProperty("webdriver.chrome.driver", "c:/temp/chromedriver.exe");
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.setBinary("c:/temp/cef_binary_76.1.13+gf19c584+chromium-76.0.3809.132_windows64_client/Release/cefclient.exe");
chromeOptions.addArguments("remote-debugging-port=XXXX");

Open a chrome driver (selenium) using the chrome options object.

WebDriver seleniumDriver = ChromeDriver(chromeOptions);

Use element inside the chromium windows. For example:

seleniumWait.until(ExpectedConditions.visibilityOfElementLocated(By.className("someButtonClassName")));
seleniumDriver.findElement(By.className("someButtonClassName")).click();

When you're done with the CEF window, close selenium driver and continue with the winium driver:

seleniumDriver.quit();
winiumDriver.findElement(By.id("someElementID")).click();

Close main winium driver:

winiumDriver.quit();

Just specify the path to the binary of the version..may be, like-

FirefoxBinary binary = new FirefoxBinary(new File("path_to_bin"));
FirefoxProfile profile = new FirefoxProfile();
WebDriver driver = new FirefoxDriver(binary, profile);

You can also check pageloaded using following code

IWait<IWebDriver> wait = new OpenQA.Selenium.Support.UI.WebDriverWait(driver, TimeSpan.FromSeconds(30.00));

 wait.Until(driver1 => ((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete"));

You are using latest version of Selenium WebDriver i.e. Selenium 3.x, this version of webdriver doesn't support direct firefox launch. You have to set the SystemProperty for webdriver.gecko.driver.

Replace the Code:-

WebDriver driver;
driver =new FirefoxDriver();

With This code:-

WebDriver driver;
System.setProperty("webdriver.gecko.driver", "<Path to your WebDriver>");
driver =new FirefoxDriver();

You can get the information about latest changes here

You can download the latest Gecko driver from here

According to JavaDocs, you can do this:

WebElement input = divA.findElement(By.xpath(".//input"));

---

How can I ask in xpath for "the div-tag that contains a span with the text 'hello world'"?

WebElement elem = driver.findElement(By.xpath("//div[span[text()='hello world']]"));

The XPath spec is a suprisingly good read on this.

You cannot do it with Selenium by itself, but you can do it executing javascript with Selenium. Js is pretty simple:

window.getSelection().toString();

So just:

((JavascriptExecutor)driver).executeScript("return window.getSelection().toString();");

PS will not work in <=IE8 (will provide how if you'll need)

You can redirect the output to a file or just discard it:

            // redirect console output from chromedriver to the file chromedriver_log.txt in the target folder
            DriverService.Builder<ChromeDriverService, ChromeDriverService.Builder> serviceBuilder = new ChromeDriverService.Builder();
            ChromeDriverService chromeDriverService = serviceBuilder.build();
            chromeDriverService.sendOutputTo(new FileOutputStream("target/chromedriver_log.txt", true));

            webDriver = new ChromeDriver(chromeDriverService, options);

If you want to just discard the output then use NullOutputStream.NULL_OUTPUT_STREAM insted off new FileOutputStream("target/chromedriver_log.txt", true)

Check the below links:

• Implicit Wait - It instructs the web driver to wait for some time by poll the DOM. Once you declared implicit wait it will be available for the entire life of web driver instance. By default the value will be 0. If you set a longer default, then the behavior will poll the DOM on a periodic basis depending on the browser/driver implementation.

• Explicit Wait + ExpectedConditions - It is the custom one. It will be used if we want the execution to wait for some time until some condition achieved.

For popups that come up at unexpected times during your execution, event handlers are the way to go. The idea is to wrap your regular driver with an EventFiringWebDriver which then lets you register handlers on certain events; of which there are many to choose from. Creating the EventFiringWebDriver is fairly simple:

EventFiringWebDriver eventDriver = new EventFiringWebDriver(driver);
EventHandler handler = new EventCaptures();
eventDriver.register(handler);
// Do stuff here
eventDriver.unregister(handler);

The handler is a method that you will implement in a separate class, derived from WebDriverEventListener, which overrides one of the base methods from that class. There are many to choose from, but a good one for this case might be beforeClickOn. Here is a sample of how that would look:

public class EventCaptures implements WebDriverEventListener{
  @Override
  public void beforeClickOn(WebElement arg0, WebDriver arg1) {
    By bounceExchangeClose = By.className("bx-close");
    if (arg1.findElements(bounceExchangeClose).size() > 0) {
      arg1.findElement(bounceExchangeClose).click();
    }       
  }
  // Other listener overrides here...
}

So basically whenever you go to click on something, that handler will run and check to make sure the pop up isn't there (and if it is, close it). Others have mentioned waits and checks, however this gets very messy if the popup is unpredictable as you then have to call that check all over the place in your code, where as with this method it happens automatically. Simply unregister the handler when you're done using it.

For more info, this is a good resource: https://www.softwaretestingmaterial.com/webdriver-event-listeners/