I had been running into this same problem for a few days and it seems that it is actually an issue with chromedriver. The solution that worked for me was to add the following flag/argument to your chromedriver options:

--disable-site-isolation-trials

Here is the chromedriver issue (and solution) I'm referring to.

If the flag does not work, you may also try upgrading to chromedriver v75

You will want to write a custom ExpectedCondition that queries angular to see if it is done. Here's one I prepared earlier:

    public static ExpectedCondition angularHasFinishedProcessing() {
        return new ExpectedCondition<Boolean>() {
            @Override
            public Boolean apply(WebDriver driver) {
                String hasAngularFinishedScript = "var callback = arguments[arguments.length - 1];\n" +
                        "var el = document.querySelector('html');\n" +
                        "if (!window.angular) {\n" +
                        "    callback('false')\n" +
                        "}\n" +
                        "if (angular.getTestability) {\n" +
                        "    angular.getTestability(el).whenStable(function(){callback('true')});\n" +
                        "} else {\n" +
                        "    if (!angular.element(el).injector()) {\n" +
                        "        callback('false')\n" +
                        "    }\n" +
                        "    var browser = angular.element(el).injector().get('$browser');\n" +
                        "    browser.notifyWhenNoOutstandingRequests(function(){callback('true')});\n" +
                        "}";

                JavascriptExecutor javascriptExecutor = (JavascriptExecutor) driver;
                String isProcessingFinished = javascriptExecutor.executeAsyncScript(hasAngularFinishedScript).toString();

                return Boolean.valueOf(isProcessingFinished);
            }
        };
    }

This is assuming that your have defined ng-app on your html element. If you define it elsewhere in the DOM you will need to update the code above. This is pretty much stolen from protractor, it's checking to see if there are any outstanding ajax requests and checking to see if angular thinks it's in a testable state.

The important part is to execute this JavaScript snippet as an async script because angular is using promises to trigger a callback when it is ready. If you don't run this as an async script it will not work.

You will also need to set a script timeout on the driver object, this is the amount of time selenium will wait for the callback to complete before throwing a timeout exception. You can set it as follows:

driver.manage().timeouts().setScriptTimeout(15, TimeUnit.SECONDS);

It's then as simple as plugging this ExpectedCondition into a wait like so:

WebDriverWait wait = new WebDriverWait(driver, 15, 100);
wait.until(angularHasFinishedProcessing());

Hope this helps.

The answer is to implement an ElementLocatorFactory that allows you to provide a search context (meaning, a driver or a WebElement).

public class SearchContextElementLocatorFactory
        implements ElementLocatorFactory {

    private final SearchContext context;

    public SearchContextElementLocatorFactory(SearchContext context) {
        this.context = context;
    }

    @Override
    public ElementLocator createLocator(Field field) {
        return new DefaultElementLocator(context, field);
    }
}

Then, when instantiating your page object, use this locator factory.

WebElement parent = driver.findElement(By.xpath("//div[contains(@class,'yui3-accordion-panel-content') and child::div[.='Sidebar']]"));
SearchContextElementLocatorFactory elementLocatorFactory = new SearchContextElementLocatorFactory(parent);
PageFactory.initElements(elementLocatorFactory, this);

Now your @FindBy annotations will be relative to parent. For example, to get the main sidebar WebElement:

@FindBy(xpath = ".")
WebElement sideBar;

After digging a little deeper, I came to the following findings which eventually solved my issue:

1. Marionette resp. wires uses two ports (see wires --help); a marionette-port and a webdriver-port:

   Usage:
       ./wires [OPTIONS]
   
   WebDriver to marionette proxy.
   
   optional arguments:
     -h,--help             show this help message and exit
     -b,--binary BINARY    Path to the Firefox binary
     --webdriver-host WEBDRIVER_HOST
                           Host to run webdriver server on
     --webdriver-port WEBDRIVER_PORT
                           Port to run webdriver on
     --marionette-port MARIONETTE_PORT
                           Port to run marionette on
     --connect-existing    Connect to an existing firefox process
   

   When running multiple MarionetteDrivers simultaneously, both ports have to be different from the already running instance obviously. However, when using the default constructor new MarionetteDriver() the marionette-port remains constant (and is not determined based on some free port). We used some workaround (see below) for the GeckoDriverService.Builder to always pick two randomly-chosen available ports.

2. The current (version 2.48.2) GeckoDriverService has an empty implementation of waitUntilAvailable() (which should check, if the WebDriver is ready to go). Sporadically, this lead to the UnreachableBrowserException posted above.

To circumvent these issues, we did something like this at the end:

// determine free ports for Marionette and WebDriver
final int marionettePort = PortProber.findFreePort();
final int webDriverPort = PortProber.findFreePort();
// override, as GeckoDriverService provides no direct way to set the Marionette port
GeckoDriverService.Builder builder = new GeckoDriverService.Builder() {
    @Override
    protected ImmutableList<String> createArgs() {
        Builder<String> argsBuilder = ImmutableList.builder();
        argsBuilder.addAll(super.createArgs());
        argsBuilder.add(String.format("--marionette-port=%d", marionettePort));
        return argsBuilder.build();
    }
};
builder.usingPort(webDriverPort);
builder.usingDriverExecutable(pathToDriver);
GeckoDriverService driverService = builder.build();
try {
    driverService.start();
} catch (IOException e) {
    throw new IllegalStateException("Could not start the GeckoDriverService", e);
}
try {
    // keep checking the WebDriver port via Socket until it's available;
    // as far as I could tell, there is nothing more "high level", e.g. REST API
    waitUntilReady(webDriverPort, TimeUnit.SECONDS.toMillis(30));
} catch (InterruptedException e) {
    // ignore
}
return new MarionetteDriver(driverService, capabilities);

Its not really possible to perform a 'mouse hover' action, instead you need to chain all of the actions that you want to achieve in one go. So move to the element that reveals the others, then during the same chain, move to the now revealed element and click on it.

When using Action Chains you have to remember to 'do it like a user would'.

Actions action = new Actions(webdriver);
WebElement we = webdriver.findElement(By.xpath("html/body/div[13]/ul/li[4]/a"));
action.moveToElement(we).moveToElement(webdriver.findElement(By.xpath("/expression-here"))).click().build().perform();

As I told the question is in implementation of JUnit.

You can see that:

Parallelized extends Parametrized extends Suite extends ParentRunner

on the other hand:

ConcurrentTestRunner extends BlockJUnit4ClassRunner extends ParentRunner

hence they are from different hierarchies of inheritance.

And now what you have to look at is implementation of the:

org.junit.runners.ParentRunner#getChildren

method. For the org.junit.runners.BlockJUnit4ClassRunner it is:

protected List<FrameworkMethod> computeTestMethods() {
    return getTestClass().getAnnotatedMethods(Test.class);
}

which generates all methods with annotations. But for org.junit.runners.Parameterized it is:

for (int i= 0; i < parametersList.size(); i++)
  runners.add(newtestClassRunnerForParameters(getTestClass().getJavaClass(),
                parametersList, i));

And the last one gives only classes.

Proposal: override your Parallelized class with definition of org.junit.runners.ParentRunner#getChildren from BlockJUnit4ClassRunner.

The error says it all :

[RemoteTestNG] detected TestNG version 6.14.2 Starting ChromeDriver (v2.9.248307) on port 34979 
[warn] kq_init: detected broken kqueue; not using.: Undefined error: 0 Mar 12, 2018 7:06:13 AM 
org.openqa.selenium.remote.ProtocolHandshake createSession 
INFO: Detected dialect: OSS FAILED: test1
org.openqa.selenium.WebDriverException: java.net.ConnectException: Failed to connect to localhost/0:0:0:0:0:0:0:1:34979 
Build info: version: '3.10.0', revision: '176b4a9', time: '2018-03-02T19:03:16.397Z' 
System info: host: 'sandeep-MacBook-Pro.local', ip: '192.168.0.100', os.name: 'Mac OS X', os.arch: 'x86_64', os.version: '10.13.3', java.version: '1.8.0_101'

Your main issue is the version compatibility between the binaries you are using as follows :

• You are using chromedriver=v2.9
• Release Notes of chromedriver=2.9 clearly mentions the following :

Supports Chrome v31-34

• Your Chrome Browser version is unknown to us. (assuming Chrome Browser is updated to v65.x level)
• Your Selenium Client version is 3.10.0.
• Your JDK version is 1.8.0_101 which is pretty ancient.

So there is a clear mismatch between the JDK v8u101 , Selenium Client v3.10.0 , ChromeDriver version (v2.9) and the current Chrome Browser version (v65.0)

Solution

• Upgrade JDK to recent levels JDK 8u162.
• Keep Selenium to current levels Version 3.10.0.
• Upgrade ChromeDriver to stable ChromeDriver v2.36 level.
• Keep Chrome version at Chrome v65.x levels. (as per ChromeDriver v2.36 release notes)
• Clean your Project Workspace through your IDE and Rebuild your project with required dependencies only.
• Use CCleaner tool to wipe off all the OS chores before and after the execution of your test Suite.
• If your base Chrome version is too old, then uninstall it through Revo Uninstaller and install a recent GA and released version of Chrome.
• Execute your @Test.

You've got two concerns to worry about. The first is making sure you've different browsers for each user, and the second is running the two users concurrently. There are a couple of different ways to do each of them, so I'll look at them separately.

Managing two browsers

The first part, that of opening two browsers, isn't too difficult; You can just create a separate WebDriver object for each one. You may have to use two different browsers, however, to avoid any kind of session sharing issues:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.chrome.ChromeDriver;

WebDriver user_1 = new FirefoxDriver();
WebDriver user_2 = new ChromeDriver();

If you need to open two instances of the same browser, your best option is to use Selenium Grid to host your desired browsers, and then creating remote connections to them:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;

DesiredCapabilities capabilities = DesiredCapabilities.firefox();
URL server = new URL("http://your-server-location.com");
WebDriver driver = new RemoteWebDriver(server, capabilities);

If you don't want to set up your own Selenium Grid, you can use a service like Sauce Labs to manage it for you (and also give you an easy way to add extra test platform resources).

Managing two users simultaneously

It sounds like you can just have the one test class performing each action in turn against the relevant Webdriver. Use something like the Page Object Model to provide service objects representing your pages, which you can pass an instance of WebDriver too. Then, you can express your test logic more fluently rather then dealing with different webdrivers and elements:

public class Chatsite{
  public WebDriver driver;
  private WebElement talkbox;
  private WebElement chatlog;
  private WebElement sendbutton;

  public Chatsite(WebDriver passed_in_driver){
      driver = passed_in_driver;
      talkbox = driver.find_element("name", "talkbox");
      sendbutton = driver.find_element("name", "send");
      chatlog = driver.find_element("name", "chatlog");
      driver.get("http://www.yoursite.com");
  }

  public void say(String string_to_type){
      talkbox.send_keys(string_to_type);
      sendbutton.click();
  }

  public void sees_in_the_chatlog(String expected_content){
      String current_chat_text =  chatlog.getText();
      assertTrue("Couldn't find content", current_chat_text.contains(expected_content));
  }
}

#Now, in your tests
#Name your users so it's easier to keep track of them
Chatsite david = Chatsite.new(user_1);
Chatsite susan = Chatsite.new(user_2);

david.say("Isn't it a fine day?");
susan.sees_in_the_chatlog("Isn't it a fine day?");

susan.say("If you're going to talk about the weather I'm failing this test case");
## And so on in that fashion

The following contains many of the avialable hooks: http://zsoltfabok.com/blog/2012/09/cucumber-jvm-hooks/

Similar to junit it appears there is an annotationo for @Before and @After