Java ExpectedCondition类代码示例

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public static ExpectedCondition<Boolean> absenceElementBy(final By locator) {
    return new ExpectedCondition<Boolean>() {
        @Override
        public Boolean apply(final WebDriver driver) {
            try {
                driver.findElement(locator);
                return false;
            } catch (WebDriverException ignored) {
                return true;
            }
        }

        @Override
        public String toString() {
            return String.format("absence of element located by %s", locator);
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * Checks if specified node property has specified value
 *
 * @param session       Jcr session.
 * @param nodePath      Absolute path to node.
 * @param propertyName  Property name.
 * @param propertyValue Property value.
 * @return True if node property has specified value.
 */
public static ExpectedCondition<Boolean> hasNodePropertyValue(final Session session,
    final String nodePath, final String propertyName, final String propertyValue) {
  LOG.debug("Checking if node '{}' has property '{}' with value '{}'", nodePath, propertyName,
      propertyValue);
  return input -> {
    Boolean result = null;
    try {
      session.refresh(true);
      result = session.getNode(nodePath).getProperty(propertyName).getValue().getString()
          .equals(propertyValue);
    } catch (RepositoryException e) {
      LOG.error(JCR_ERROR, e);
    }
    return result;
  };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * We don't know the actual window title without switching to one.
 * This method was always used to make sure that the window appeared. After it we switched to appeared window.
 * Switching between windows is rather time consuming operation
 * <p>
 * To avoid the double switching to the window we are switching to window in this method
 * <p>
 * The same approach is applies to all ExpectedConditions for windows
 *
 * @param title - title of window
 * @return - handle of expected window
 */
public static ExpectedCondition<String> appearingOfWindowAndSwitchToIt(final String title) {
    return new ExpectedCondition<String>() {
        @Override
        public String apply(final WebDriver driver) {
            final String initialHandle = driver.getWindowHandle();
            for (final String handle : driver.getWindowHandles()) {
                if (needToSwitch(initialHandle, handle)) {
                    driver.switchTo().window(handle);
                    if (driver.getTitle().equals(title)) {
                        return handle;
                    }
                }
            }
            driver.switchTo().window(initialHandle);
            return null;
        }

        @Override
        public String toString() {
            return String.format("appearing of window by title %s and switch to it", title);
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * Clicks button at the bottom of edit Window and expect for dialog to disappear.
 *
 * @param buttonText button label
 * @return Returns this dialog instance.
 */
public AemDialog clickDialogFooterButton(final String buttonText) {
  final WebElement footerButton = getFooterButtonWebElement(buttonText);

  bobcatWait.withTimeout(Timeouts.BIG).until((ExpectedCondition<Object>) input -> {
    try {
      footerButton.click();
      footerButton.isDisplayed();
      return Boolean.FALSE;
    } catch (NoSuchElementException | StaleElementReferenceException
        | ElementNotVisibleException e) {
      LOG.debug("Dialog footer button is not available: {}", e);
      return Boolean.TRUE;
    }
  }, 2);
  bobcatWait.withTimeout(Timeouts.MEDIUM).until(CommonExpectedConditions.noAemAjax());
  return this;
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public static ExpectedCondition<Boolean> ajaxCompleted() {
    return new ExpectedCondition<Boolean>() {
        boolean result;
        @Override
        public Boolean apply(WebDriver driver) {
            try {
                result = (Boolean) ((JavascriptExecutor) driver).executeScript("return typeof($) !== 'undefined' && $.active == 0");
                //System.out.println("Ajax return $.active == 0  is: '" + result + "'");
            } catch (WebDriverException e) {
                return false;
            }
            return result;
        }
        public String toString() {
            return "Ajax return $.active == 0  is: '" + result + "'";
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * 根据标题中包含某个子串来等待
 * @param title 标题子串
 * @param timeOutInMillis 超时时间毫秒数
 * @param delayedMillis 延迟毫秒数
 */
public void waitWithTitleAndDelayed(final String title, int timeOutInMillis, int delayedMillis) {
    (new WebDriverWait(this, timeOutInMillis/1000)).until(new ExpectedCondition<Boolean>() {
        public Boolean apply(WebDriver d) {
            String t = d.getTitle();
            if (StringUtils.isEmpty(title)) {
                //等到有title就停止
                return StringUtils.isNotBlank(t);
            }
            return t != null && t.contains(title);
        }
    });
    if (delayedMillis > 0) {
        sleep(delayedMillis);
    }
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * 根据内容中包含某个子串来等待
 * @param content 内容子串
 * @param timeOutInMillis 超时时间毫秒数
 * @param delayedMillis 延迟毫秒数
 */
public void waitWithContentAndDelayed(final String content, int timeOutInMillis, int delayedMillis) {
    (new WebDriverWait(this, timeOutInMillis/1000)).until(new ExpectedCondition<Boolean>() {
        public Boolean apply(WebDriver d) {
            String html = d.getPageSource();
            if (StringUtils.isEmpty(content)) {
                //等到有内容就停止
                return StringUtils.isNotBlank(html);
            }
            return html != null && html.contains(content);
        }
    });
    if (delayedMillis > 0) {
        sleep(delayedMillis);
    }
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public static ExpectedCondition<String> appearingOfWindowByPartialTitle(final String fullTitle) {
    return new ExpectedCondition<String>() {
        @Override
        public String apply(final WebDriver driver) {
            final String initialHandle = driver.getWindowHandle();
            for (final String handle : driver.getWindowHandles()) {
                if (needToSwitch(initialHandle, handle)) {
                    driver.switchTo().window(handle);
                    if (fullTitle.contains(driver.getTitle().split("\\(")[0].trim())) {
                        return handle;
                    }
                }
            }
            driver.switchTo().window(initialHandle);
            return null;
        }

        @Override
        public String toString() {
            return String.format("appearing of window by partial title %s and switch to it", fullTitle);
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public static ExpectedCondition<String> appearingOfWindowWithNewTitle(final Set<String> oldTitle) {
    return new ExpectedCondition<String>() {
        @Override
        public String apply(final WebDriver driver) {
            Set<String> windowHandles = driver.getWindowHandles();
            if (windowHandles.containsAll(oldTitle)) {
                windowHandles.removeAll(oldTitle);
                if (!windowHandles.isEmpty()) {
                    return windowHandles.iterator().next();
                }
            }
            return null;
        }

        @Override
        public String toString() {
            return String.format("appearing of window with new title. Old windows titles %s", oldTitle);
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public static ExpectedCondition<String> appearingOfWindowByPartialUrl(final String url) {
    return new ExpectedCondition<String>() {
        @Override
        public String apply(final WebDriver driver) {
            final String initialHandle = driver.getWindowHandle();
            for (final String handle : driver.getWindowHandles()) {
                if (needToSwitch(initialHandle, handle)) {
                    driver.switchTo().window(handle);
                    if (driver.getCurrentUrl().contains(url)) {
                        return handle;
                    }
                }
            }
            driver.switchTo().window(initialHandle);
            return null;
        }

        @Override
        public String toString() {
            return String.format("appearing of window by partial url %s and switch to it", url);
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * Returns a 'wait' proxy that determines if the specified element reference has gone stale.
 *
 * @param element the element to wait for
 * @return 'false' if the element reference is still valid; otherwise 'true'
 */
public static Coordinator<Boolean> stalenessOf(final WebElement element) {
    return new Coordinator<Boolean>() {
        private final ExpectedCondition<Boolean> condition = conditionInitializer();

        // initializer for [condition] field
        private final ExpectedCondition<Boolean> conditionInitializer() {
            if (element instanceof WrapsElement) {
                return ExpectedConditions.stalenessOf(((WrapsElement) element).getWrappedElement());
            } else {
                return ExpectedConditions.stalenessOf(element);
            }
        }

        @Override
        public Boolean apply(SearchContext ignored) {
            return condition.apply(null);
        }

        @Override
        public String toString() {
            return condition.toString();
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public void progress() throws Throwable {
    driver = new JavaDriver();
    final WebElement progressbar = driver.findElement(By.cssSelector("progress-bar"));
    AssertJUnit.assertNotNull("could not find progress-bar", progressbar);
    AssertJUnit.assertEquals("0", progressbar.getAttribute("value"));
    driver.findElement(By.cssSelector("button")).click();

    Wait<WebDriver> wait = new WebDriverWait(driver, 30);
    // Wait for a process to complete
    wait.until(new ExpectedCondition<Boolean>() {
        @Override public Boolean apply(WebDriver webDriver) {
            return progressbar.getAttribute("value").equals("100");
        }
    });

    AssertJUnit.assertEquals("100", progressbar.getAttribute("value"));
    AssertJUnit.assertTrue(driver.findElement(By.cssSelector("text-area")).getText().contains("Done!"));
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * Expects that the target element contains the given value as text.
 * The inner text and 'value' attribute of the element is checked.
 *
 * @param locator
 *            is the selenium locator
 * @param value
 *            is the expected value
 * @return true or false
 */
public static ExpectedCondition<Boolean> textToBeEqualsToExpectedValue(final By locator, final String value) {
    return new ExpectedCondition<Boolean>() {
        /**
         * {@inheritDoc}
         */
        @Override
        public Boolean apply(@Nullable WebDriver driver) {
            try {
                WebElement element = driver.findElement(locator);
                if (element != null && value != null) {
                    if (element.getAttribute(VALUE) == null || !value.equals(element.getAttribute(VALUE).trim())) {
                        if (!value.equals(element.getText())) {
                            return false;
                        }
                    }
                    return true;
                }
            } catch (Exception e) {
            }
            return false;
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
public static ExpectedCondition<WebElement> atLeastOneOfTheseElementsIsPresent(final By... locators) {
    return new ExpectedCondition<WebElement>() {
        @Override
        public WebElement apply(@Nullable WebDriver driver) {
            WebElement element = null;
            if (driver != null && locators.length > 0) {
                for (final By b : locators) {
                    try {
                        element = driver.findElement(b);
                    } catch (final Exception e) {
                        continue;
                    }
                }
            }
            return element;
        }
    };
}
 

import org.openqa.selenium.support.ui.ExpectedCondition; //导入依赖的package包/类
/**
 * An expectation for checking that nb elements present on the web page that match the locator
 * are visible. Visibility means that the elements are not only displayed but also have a height
 * and width that is greater than 0.
 *
 * @param locator
 *            used to find the element
 * @param nb
 *            is exactly number of responses
 * @return the list of WebElements once they are located
 */
public static ExpectedCondition<List<WebElement>> visibilityOfNbElementsLocatedBy(final By locator, final int nb) {
    return new ExpectedCondition<List<WebElement>>() {
        @Override
        public List<WebElement> apply(WebDriver driver) {
            int nbElementIsDisplayed = 0;
            final List<WebElement> elements = driver.findElements(locator);
            for (final WebElement element : elements) {
                if (element.isDisplayed()) {
                    nbElementIsDisplayed++;
                }
            }
            return nbElementIsDisplayed == nb ? elements : null;
        }
    };
}