Waiting for things to happen

import pytest
import time
from selenium.common import NoSuchElementException, ElementNotInteractableException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait


def test_fails(driver):
    driver.get('https://www.selenium.dev/selenium/web/dynamic.html')
    driver.find_element(By.ID, "adder").click()

    with pytest.raises(NoSuchElementException):
        driver.find_element(By.ID, 'box0')


def test_sleep(driver):
    driver.get('https://www.selenium.dev/selenium/web/dynamic.html')
    driver.find_element(By.ID, "adder").click()

    time.sleep(2)
    added = driver.find_element(By.ID, "box0")

    assert added.get_dom_attribute('class') == "redbox"


def test_implicit(driver):
    driver.implicitly_wait(2)
    driver.get('https://www.selenium.dev/selenium/web/dynamic.html')
    driver.find_element(By.ID, "adder").click()

    added = driver.find_element(By.ID, "box0")

    assert added.get_dom_attribute('class') == "redbox"


def test_explicit(driver):
    driver.get('https://www.selenium.dev/selenium/web/dynamic.html')
    revealed = driver.find_element(By.ID, "revealed")
    driver.find_element(By.ID, "reveal").click()

    wait = WebDriverWait(driver, timeout=2)
    wait.until(lambda _ : revealed.is_displayed())

    revealed.send_keys("Displayed")
    assert revealed.get_property("value") == "Displayed"


def test_explicit_options(driver):
    driver.get('https://www.selenium.dev/selenium/web/dynamic.html')
    revealed = driver.find_element(By.ID, "revealed")
    driver.find_element(By.ID, "reveal").click()

    errors = [NoSuchElementException, ElementNotInteractableException]
    wait = WebDriverWait(driver, timeout=2, poll_frequency=.2, ignored_exceptions=errors)
    wait.until(lambda _ : revealed.send_keys("Displayed") or True)

    assert revealed.get_property("value") == "Displayed"


def test_expected_conditions(driver):
    driver.get('https://www.selenium.dev/selenium/web/web-form.html')
    driver.find_element(By.ID, "my-text-id").send_keys("Selenium")
    driver.find_element(By.CSS_SELECTOR, "button").click()

    wait = WebDriverWait(driver, timeout=2)
    wait.until(EC.title_is("Web form - target page"))
    message = wait.until(EC.presence_of_element_located((By.ID, "message")))
    wait.until(EC.visibility_of(message))
    wait.until(EC.text_to_be_present_in_element((By.ID, "message"), "Received!"))

    assert message.text == "Received!"

using System;
using System.Threading;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;

namespace SeleniumDocs.Waits
{
    [TestClass]
    public class WaitsTest : BaseChromeTest
    {
        [TestMethod]
        public void Fails()
        {
            driver.Url = "https://www.selenium.dev/selenium/web/dynamic.html";
            driver.FindElement(By.Id("adder")).Click();

            Assert.ThrowsException<NoSuchElementException>(
                () => driver.FindElement(By.Id("box0"))
            );
        }

        [TestMethod]
        public void Sleep()
        {
            driver.Url = "https://www.selenium.dev/selenium/web/dynamic.html";
            driver.FindElement(By.Id("adder")).Click();

            Thread.Sleep(1000);

            IWebElement added = driver.FindElement(By.Id("box0"));

            Assert.AreEqual("redbox", added.GetDomAttribute("class"));
        }

        [TestMethod]
        public void Implicit()
        {
            driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(2);
            
            driver.Url = "https://www.selenium.dev/selenium/web/dynamic.html";
            driver.FindElement(By.Id("adder")).Click();

            IWebElement added = driver.FindElement(By.Id("box0"));

            Assert.AreEqual("redbox", added.GetDomAttribute("class"));
        }

        [TestMethod]
        public void Explicit()
        {
            driver.Url = "https://www.selenium.dev/selenium/web/dynamic.html";
            IWebElement revealed = driver.FindElement(By.Id("revealed"));
            driver.FindElement(By.Id("reveal")).Click();

            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(2));
            wait.Until(d => revealed.Displayed);

            revealed.SendKeys("Displayed");
            Assert.AreEqual("Displayed", revealed.GetDomProperty("value"));
        }

        [TestMethod]
        public void ExplicitOptions()
        {
            driver.Url = "https://www.selenium.dev/selenium/web/dynamic.html";
            IWebElement revealed = driver.FindElement(By.Id("revealed"));
            driver.FindElement(By.Id("reveal")).Click();

            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(2))
            {
                PollingInterval = TimeSpan.FromMilliseconds(300),
            };
            wait.IgnoreExceptionTypes(typeof(ElementNotInteractableException));

            wait.Until(d => {
                revealed.SendKeys("Displayed");
                return true;
            });

            Assert.AreEqual("input", revealed.TagName);
        }
    }
}

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Waits' do
  let(:driver) { start_session }

  it 'fails' do
    driver.get 'https://www.selenium.dev/selenium/web/dynamic.html'
    driver.find_element(id: 'adder').click

    expect {
      driver.find_element(id: 'box0')
    }.to raise_error(Selenium::WebDriver::Error::NoSuchElementError)
  end

  it 'sleeps' do
    driver.get 'https://www.selenium.dev/selenium/web/dynamic.html'
    driver.find_element(id: 'adder').click

    sleep 1
    added = driver.find_element(id: 'box0')

    expect(added.dom_attribute(:class)).to eq('redbox')
  end

  it 'implicit' do
    driver.manage.timeouts.implicit_wait = 2
    driver.get 'https://www.selenium.dev/selenium/web/dynamic.html'
    driver.find_element(id: 'adder').click

    added = driver.find_element(id: 'box0')

    expect(added.dom_attribute(:class)).to eq('redbox')
  end

  it 'explicit' do
    driver.get 'https://www.selenium.dev/selenium/web/dynamic.html'
    revealed = driver.find_element(id: 'revealed')
    driver.find_element(id: 'reveal').click

    wait = Selenium::WebDriver::Wait.new
    wait.until { revealed.displayed? }

    revealed.send_keys('Displayed')
    expect(revealed.property(:value)).to eq('Displayed')
  end

  it 'options with explicit' do
    driver.get 'https://www.selenium.dev/selenium/web/dynamic.html'
    revealed = driver.find_element(id: 'revealed')
    driver.find_element(id: 'reveal').click

    errors = [Selenium::WebDriver::Error::NoSuchElementError,
              Selenium::WebDriver::Error::ElementNotInteractableError]
    wait = Selenium::WebDriver::Wait.new(timeout: 2,
                                         interval: 0.3,
                                         ignore: errors)

    wait.until { revealed.send_keys('Displayed') || true }

    expect(revealed.property(:value)).to eq('Displayed')
  end
end

const { By, Browser, until, Builder} = require('selenium-webdriver');
const assert = require("node:assert");


describe('Waits', function () {
    let driver;

    before(async function () {
        driver = new Builder()
          .forBrowser(Browser.CHROME)
          .build();
    });

    after(async () => await driver.quit());

    it('fail', async function () {
        await driver.get('https://www.selenium.dev/selenium/web/dynamic.html');
        await driver.findElement(By.id("adder")).click();

        await assert.rejects(async () => {
              await driver.findElement(By.id("box0"))
          },
          Error
        )
    });

    it('sleep', async function () {
        await driver.get('https://www.selenium.dev/selenium/web/dynamic.html');
        await driver.findElement(By.id("adder")).click();

        await driver.sleep(2000);
        let added = await driver.findElement(By.id("box0"));

        assert.equal(await added.getAttribute('class'), "redbox")
    });

    it('implicit', async function () {
        await driver.manage().setTimeouts({ implicit: 2000 });
        await driver.get('https://www.selenium.dev/selenium/web/dynamic.html');
        await driver.findElement(By.id("adder")).click();

        let added = await driver.findElement(By.id("box0"));

        assert.equal(await added.getAttribute('class'), "redbox")
    });

    it('explicit', async function () {
        await driver.get('https://www.selenium.dev/selenium/web/dynamic.html');
        let revealed = await driver.findElement(By.id("revealed"));
        await driver.findElement(By.id("reveal")).click();
        await driver.wait(until.elementIsVisible(revealed), 2000);
        await revealed.sendKeys("Displayed");
        assert.equal(await revealed.getAttribute("value"), "Displayed")
    })

    it('expected conditions', async function () {
        await driver.get('https://www.selenium.dev/selenium/web/web-form.html');
        await driver.findElement(By.id("my-text-id")).sendKeys("Selenium");
        await driver.findElement(By.css("button")).click();

        await driver.wait(until.titleIs("Web form - target page"), 2000);
        let message = await driver.wait(until.elementLocated(By.id("message")), 2000);
        await driver.wait(until.elementIsVisible(message), 2000);
        await driver.wait(until.elementTextIs(message, "Received!"), 2000);

        assert.equal(await message.getText(), "Received!")
    })
});

package dev.selenium.waits

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.ElementNotInteractableException
import org.openqa.selenium.WebDriver
import org.openqa.selenium.support.ui.FluentWait
import org.openqa.selenium.support.ui.Wait
import org.openqa.selenium.support.ui.WebDriverWait
import java.time.Duration


class WaitsTest : BaseTest() {

    @Test
    fun implicit() {
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(2))
        driver.get("https://www.selenium.dev/selenium/web/dynamic.html")
        driver.findElement(By.id("adder")).click()

        val added = driver.findElement(By.id("box0"))

        Assertions.assertEquals("redbox",added.getDomAttribute("class"))

    }

    @Test
    fun explicit() {

        driver.get("https://www.selenium.dev/selenium/web/dynamic.html")
        val revealed = driver.findElement(By.id("revealed"))
        driver.findElement(By.id("reveal")).click()

        val wait =  WebDriverWait(driver, Duration.ofSeconds(2))
        wait.until { revealed.isDisplayed }

        revealed.sendKeys("Displayed")
        Assertions.assertEquals("Displayed", revealed.getDomProperty("value"))
    }

    @Test
    fun explicitWithOptions() {

        driver.get("https://www.selenium.dev/selenium/web/dynamic.html")

        val revealed = driver.findElement(By.id("revealed"))
        driver.findElement(By.id("reveal")).click()

        val wait: Wait<WebDriver> =
            FluentWait(driver)
                .withTimeout(Duration.ofSeconds(2))
                .pollingEvery(Duration.ofMillis(300))
                .ignoring(ElementNotInteractableException::class.java)

        wait.until {
            revealed.sendKeys("Displayed")
            true
        }

        Assertions.assertEquals("Displayed", revealed.getDomProperty("value"))
    }

}