Selenium Waits and Synchronization

NoSuchElementException: Unable to locate element
ElementNotInteractableException: Element is not clickable
StaleElementReferenceException: Element is no longer attached to the DOM

// This will often fail
driver.get("https://example.com/dashboard");
driver.findElement(By.id("user-data")).click(); // Element not loaded yet!

// Java - Set once after creating driver
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

# Python
driver.implicitly_wait(10)  # seconds

// Typical implicit wait setup
WebDriver driver = new ChromeDriver();
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(5));

// Java
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(
    ExpectedConditions.visibilityOfElementLocated(By.id("dynamic-content"))
);

# Python
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
 
wait = WebDriverWait(driver, 10)
element = wait.until(
    EC.visibility_of_element_located((By.ID, "dynamic-content"))
)

// Full constructor options
WebDriverWait wait = new WebDriverWait(
    driver,                          // WebDriver instance
    Duration.ofSeconds(10),          // Timeout
    Duration.ofMillis(500)           // Polling interval (optional)
);

// Wait for element to be visible
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("element")));
 
// Wait for element to be clickable
wait.until(ExpectedConditions.elementToBeClickable(By.id("button")));
 
// Wait for text to appear
wait.until(ExpectedConditions.textToBePresentInElementLocated(
    By.id("status"), "Complete"
));
 
// Wait for element to disappear
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id("loader")));
 
// Wait for URL to contain string
wait.until(ExpectedConditions.urlContains("/dashboard"));

// Wait returns the element, so you can chain actions
wait.until(ExpectedConditions.elementToBeClickable(By.id("submit"))).click();
 
// Or store and use later
WebElement button = wait.until(
    ExpectedConditions.elementToBeClickable(By.id("submit"))
);
button.click();

// Java
Wait<WebDriver> fluentWait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofMillis(250))
    .ignoring(NoSuchElementException.class)
    .ignoring(StaleElementReferenceException.class);
 
WebElement element = fluentWait.until(driver ->
    driver.findElement(By.id("dynamic-element"))
);

# Python
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import NoSuchElementException, StaleElementReferenceException
 
wait = WebDriverWait(
    driver,
    timeout=30,
    poll_frequency=0.25,
    ignored_exceptions=[NoSuchElementException, StaleElementReferenceException]
)
 
element = wait.until(lambda d: d.find_element(By.ID, "dynamic-element"))

// Example: Wait for element that might go stale
Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(20))
    .pollingEvery(Duration.ofMillis(500))
    .ignoring(StaleElementReferenceException.class);
 
wait.until(driver -> {
    WebElement element = driver.findElement(By.id("updating-content"));
    return element.getText().contains("Ready");
});

// Example: Wait for element visible AND clickable
wait.until(ExpectedConditions.and(
    ExpectedConditions.visibilityOfElementLocated(By.id("btn")),
    ExpectedConditions.elementToBeClickable(By.id("btn"))
));

// Java - Wait for specific text in element
wait.until(driver -> {
    String text = driver.findElement(By.id("status")).getText();
    return text.equals("Processing Complete");
});

# Python
wait.until(lambda driver:
    driver.find_element(By.ID, "status").text == "Processing Complete"
)

// Java - Reusable custom condition
public class CustomConditions {
 
    public static ExpectedCondition<Boolean> elementHasClass(
            By locator, String className) {
        return driver -> {
            WebElement element = driver.findElement(locator);
            String classes = element.getAttribute("class");
            return classes != null && classes.contains(className);
        };
    }
 
    public static ExpectedCondition<Boolean> ajaxComplete() {
        return driver -> {
            JavascriptExecutor js = (JavascriptExecutor) driver;
            return (Boolean) js.executeScript(
                "return jQuery.active == 0"
            );
        };
    }
}
 
// Usage
wait.until(CustomConditions.elementHasClass(By.id("btn"), "active"));
wait.until(CustomConditions.ajaxComplete());

// Wait for page to fully load
wait.until(driver -> {
    JavascriptExecutor js = (JavascriptExecutor) driver;
    return js.executeScript("return document.readyState").equals("complete");
});
 
// Wait for Angular
wait.until(driver -> {
    JavascriptExecutor js = (JavascriptExecutor) driver;
    return (Boolean) js.executeScript(
        "return window.getAllAngularTestabilities().every(t => t.isStable())"
    );
});
 
// Wait for network idle (no pending requests)
wait.until(driver -> {
    JavascriptExecutor js = (JavascriptExecutor) driver;
    return (Long) js.executeScript(
        "return window.performance.getEntriesByType('resource').filter(r => !r.responseEnd).length"
    ) == 0;
});

// Problem: Element becomes stale
WebElement element = driver.findElement(By.id("dynamic"));
// ... page updates via AJAX ...
element.click(); // StaleElementReferenceException!
 
// Solution 1: Re-find the element
driver.findElement(By.id("dynamic")).click();
 
// Solution 2: Use Fluent Wait with ignored exception
Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(10))
    .ignoring(StaleElementReferenceException.class);
 
wait.until(driver -> {
    driver.findElement(By.id("dynamic")).click();
    return true;
});

// Problem: Click intercepted by overlay
wait.until(ExpectedConditions.elementToBeClickable(By.id("btn"))).click();
// ElementClickInterceptedException: Other element would receive the click
 
// Solution: Wait for overlay to disappear first
wait.until(ExpectedConditions.invisibilityOfElementLocated(
    By.className("loading-overlay")
));
wait.until(ExpectedConditions.elementToBeClickable(By.id("btn"))).click();

// Problem: Using presenceOf when you need visibilityOf
wait.until(ExpectedConditions.presenceOfElementLocated(By.id("modal")));
driver.findElement(By.id("modal-button")).click(); // Element not visible!
 
// Solution: Wait for visibility
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("modal")));

// Problem: 10-second delay on every "element not found"
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
List<WebElement> errors = driver.findElements(By.className("error"));
// Waits 10 seconds even when there are no errors
 
// Solution: Temporarily reduce implicit wait
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(0));
List<WebElement> errors = driver.findElements(By.className("error"));
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10)); // Restore

// Create a reusable wait helper
public class WaitHelper {
    private WebDriverWait wait;
 
    public WaitHelper(WebDriver driver, int timeoutSeconds) {
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(timeoutSeconds));
    }
 
    public WebElement waitForClickable(By locator) {
        return wait.until(ExpectedConditions.elementToBeClickable(locator));
    }
 
    public void waitForInvisible(By locator) {
        wait.until(ExpectedConditions.invisibilityOfElementLocated(locator));
    }
 
    public WebElement waitForVisible(By locator) {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(locator));
    }
}

// Never do this
Thread.sleep(5000); // Wastes 5 seconds even if element appears immediately
 
// Do this instead
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("element")));

// Wrong: Wait after the action
button.click();
Thread.sleep(2000);
assertEquals("Success", status.getText());
 
// Right: Wait for the expected state
button.click();
wait.until(ExpectedConditions.textToBePresentInElement(status, "Success"));
assertEquals("Success", status.getText());

// Too generic - element might be hidden
wait.until(ExpectedConditions.presenceOfElementLocated(By.id("btn")));
 
// Better - ensures element is interactable
wait.until(ExpectedConditions.elementToBeClickable(By.id("btn")));

public class CheckoutPage {
    private WebDriver driver;
    private WebDriverWait wait;
 
    public CheckoutPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }
 
    public void waitForPageLoad() {
        wait.until(ExpectedConditions.visibilityOfElementLocated(
            By.id("checkout-form")
        ));
        wait.until(ExpectedConditions.invisibilityOfElementLocated(
            By.className("spinner")
        ));
    }
 
    public void waitForPaymentProcessing() {
        // Payment can take longer
        WebDriverWait longWait = new WebDriverWait(driver, Duration.ofSeconds(60));
        longWait.until(ExpectedConditions.or(
            ExpectedConditions.urlContains("/confirmation"),
            ExpectedConditions.visibilityOfElementLocated(By.className("error"))
        ));
    }
}

Is the element always on page?
├── Yes → Is it a simple, static page?
│         ├── Yes → Implicit wait (5-10s) is sufficient
│         └── No → Use explicit wait for specific conditions
└── No → Use explicit wait with appropriate ExpectedCondition
         ├── Need element visible? → visibilityOfElementLocated
         ├── Need to click? → elementToBeClickable
         ├── Need element gone? → invisibilityOfElementLocated
         └── Complex condition? → Custom wait or FluentWait