Wait until element doesn't exists using PageFactory

I'm trying to use only PageFactory in my project, without using fields with type By. And I'm looking to implement something like this:

@FindBy(className = "loading-container")
private WebElement loadingElement;

public LoadingPage(WebDriver driver) {
    PageFactory.initElements(driver, this);
    this.waitDriver = new WebDriverWait(this.driver, 20);
}

public void waitLoadingToFinish() {
    this.waitDriver.until(ExpectedConditions.elementNotExists(loadingElement));
}

Is there a way to implemet custom Expected Condition for this? or any other way to implement this? (without using By fields, only using page factory).

As far as I understand you have some elements on the page that you consider ready for usage only when there is no certain element on the page (like waiting wheel).

There is a special locator class in Selenium called AjaxElementLocator. What you need to do is to extend that type by changing isElementUsable method when you initialize your page so that all the controls you use on that page would first check the condition. Here is the example:

package click.webelement.pagefactory.conditions;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.PageFactory;
import org.openqa.selenium.support.pagefactory.AjaxElementLocator;

public class LoadablePage {

    @FindBy(id = "cntrl-id")
    WebElement control;

    public LoadablePage(WebDriver driver){
        PageFactory.initElements(field -> new AjaxElementLocator(driver, field, 10){
            @Override
            protected boolean isElementUsable(WebElement element) {
                return driver.findElements(By.xpath("//WHEEL_XPATH")).size() == 0;
            }
        }, this);
    }

}

Here you can find more information on such approach.

Selenium has this method

> ExpectedConditions.InvisibilityOfElementLocated
>
> An expectation for checking that an element is either invisible or not
> present on the DOM.

For your code

public void waitLoadingToFinish() {
    this.waitDriver.until(ExpectedConditions.invisibilityOfElementLocated(loadingElement));
}

also, you might try to add a javascript executor to wait until the page is loaded

public static void waitForScriptsToLoad(WebDriver driver) {
    WebDriverWait(driver, 30).until((ExpectedCondition<Boolean>) wd ->
            ((JavascriptExecutor) wd).executeScript("return document.readyState").equals("complete"));
}

and then your page constructor becomes this

public LoadingPage(WebDriver driver) {
    PageFactory.initElements(driver, this);
    this.waitDriver = new WebDriverWait(this.driver, 20);
    waitForScriptsToLoad(driver);
}

If you create wait method in your program that is easy and customize in selenium framework 

 private static WebElement waitForElement(By locator, int timeout)
    {
        WebElement element=new WebDriverWait(driver,timeout).until(ExpectedConditions.presenceOfElementLocated(locator));
        return element;
    }


//If you want wait for id  following code should use 

waitForElement(By.id(""),20);
Here 20 is miliseconds

and you can use any web elements to wait

To simulate an ExpectedConditions like elementNotExists you can use either among invisibilityOfElementLocated() or invisibilityOf().

invisibilityOfElementLocated()

invisibilityOfElementLocated() is the implementation for an expectation for checking that an element is either invisible or not present on the DOM. It is defined as follows:

public static ExpectedCondition<java.lang.Boolean> invisibilityOfElementLocated(By locator)
An expectation for checking that an element is either invisible or not present on the DOM.

Parameters:
	locator - used to find the element

Returns:
	true if the element is not displayed or the element doesn't exist or stale element

• Code Block:

    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.support.FindBy;
    import org.openqa.selenium.support.PageFactory;
    import org.openqa.selenium.support.ui.WebDriverWait;
  
    public class fooPage {
  
    	WebDriver driver;
    	public fooPage(WebDriver driver)
    	{
    		PageFactory.initElements(driver, this);
    	}
  
    	//you don't need this
    	//@FindBy(className = "loading-container")
    	//private WebElement loadingElement;
  
    	public void foo()
    	{
    		Boolean bool = new WebDriverWait(driver, 20).until(ExpectedConditions.invisibilityOfElementLocated(By.className('loading-container')));
    		//other lines of code
    	}
    }
  

As an alternative you can also use the invisibilityOf() method as follows:

invisibilityOf()

invisibilityOf() is the implementation for an expectation for checking the element to be invisible. It is defined as follows:

public static ExpectedCondition<java.lang.Boolean> invisibilityOf(WebElement element)
An expectation for checking the element to be invisible

Parameters:
	element - used to check its invisibility

Returns:
	Boolean true when elements is not visible anymore

• Code Block:

    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.support.FindBy;
    import org.openqa.selenium.support.PageFactory;
    import org.openqa.selenium.support.ui.WebDriverWait;
  
    public class fooPage {
  
    	WebDriver driver;
    	public fooPage(WebDriver driver)
    	{
    		PageFactory.initElements(driver, this);
    	}
  
  
    	@FindBy(className= 'loading-container')
    	WebElement loadingElement;
  
    	public void foo()
    	{
    		Boolean bool = new WebDriverWait(driver, 20).until(ExpectedConditions.invisibilityOf(fooPage.getWebElement()));
    		//other lines of code
    	}
  
    	public WebElement getWebElement()
    	{
    	    return loadingElement;
    	}
    }
  

>You can find a detailed discussion in How to use explicit waits with PageFactory fields and the PageObject pattern