Selenium 高阶应用之WebDriverWait 和 expected_conditions

　　Seleniium 是相当不错的一个第三方测试框架，可惜目前国内已经无法访问其官网（翻墙可以）。

不知道大家是否有认真查看过selenium 的api，我是有认真学习过的。selenium 的api中包含有WebDriverWait  和 expected_conditions这两个高级应用。

　　下面先看WebDriverWait ：

 import time
 from selenium.common.exceptions import NoSuchElementException
 from selenium.common.exceptions import TimeoutException

 POLL_FREQUENCY = 0.5  # How long to sleep inbetween calls to the method
 IGNORED_EXCEPTIONS = (NoSuchElementException,)  # exceptions ignored during calls to the method

 class WebDriverWait(object):
     def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, ignored_exceptions=None):
         """Constructor, takes a WebDriver instance and timeout in seconds.

            :Args:
             - driver - Instance of WebDriver (Ie, Firefox, Chrome or Remote)
             - timeout - Number of seconds before timing out
             - poll_frequency - sleep interval between calls
               By default, it is 0.5 second.
             - ignored_exceptions - iterable structure of exception classes ignored during calls.
               By default, it contains NoSuchElementException only.

            Example:
             from selenium.webdriver.support.ui import WebDriverWait \n
             element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \n
             is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\ \n
                         until_not(lambda x: x.find_element_by_id("someId").is_displayed())
         """
         self._driver = driver
         self._timeout = timeout
         self._poll = poll_frequency
         # avoid the divide by zero
         if self._poll == 0:
             self._poll = POLL_FREQUENCY
         exceptions = list(IGNORED_EXCEPTIONS)
         if ignored_exceptions is not None:
             try:
                 exceptions.extend(iter(ignored_exceptions))
             except TypeError:  # ignored_exceptions is not iterable
                 exceptions.append(ignored_exceptions)
         self._ignored_exceptions = tuple(exceptions)

     def until(self, method, message=''):
         """Calls the method provided with the driver as an argument until the \
         return value is not False."""
         screen = None
         stacktrace = None

         end_time = time.time() + self._timeout
         while True:
             try:
                 value = method(self._driver)
                 if value:
                     return value
             except self._ignored_exceptions as exc:
                 screen = getattr(exc, 'screen', None)
                 stacktrace = getattr(exc, 'stacktrace', None)
             time.sleep(self._poll)
             if time.time() > end_time:
                 break
         raise TimeoutException(message, screen, stacktrace)

     def until_not(self, method, message=''):
         """Calls the method provided with the driver as an argument until the \
         return value is False."""
         end_time = time.time() + self._timeout
         while True:
             try:
                 value = method(self._driver)
                 if not value:
                     return value
             except self._ignored_exceptions:
                 return True
             time.sleep(self._poll)
             if time.time() > end_time:
                 break
         raise TimeoutException(message)

　哈哈，我始终相信贴出来总会有人看。WebDriverWait 类位于selenium.webdriver.support.ui下面的例子很简单，

Example:

 from selenium.webdriver.support.ui import WebDriverWait
 element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId"))
 is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).
                  until_not(lambda x: x.find_element_by_id("someId").is_displayed())

WebDriverWait 里面主要有两个方法，一个是until和until_not

那么我们可以这样用：

WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("某个按钮")).click()

意思就是在10秒内等待某个按钮被定位到，咱们再去点击。就是每隔0.5秒内调用一下until里面的表达式或者方法函数，要么10秒内表达式执行成功，要么10秒后抛出超时异常。

然后我们再看expected_conditions：

 from selenium.common.exceptions import NoSuchElementException
 from selenium.common.exceptions import NoSuchFrameException
 from selenium.common.exceptions import StaleElementReferenceException
 from selenium.common.exceptions import WebDriverException
 from selenium.common.exceptions import NoAlertPresentException

 """
  * Canned "Expected Conditions" which are generally useful within webdriver
  * tests.
 """
 class title_is(object):
     """An expectation for checking the title of a page.
     title is the expected title, which must be an exact match
     returns True if the title matches, false otherwise."""
     def __init__(self, title):
         self.title = title

     def __call__(self, driver):
         return self.title == driver.title

 class title_contains(object):
     """ An expectation for checking that the title contains a case-sensitive
     substring. title is the fragment of title expected
     returns True when the title matches, False otherwise
     """
     def __init__(self, title):
         self.title = title

     def __call__(self, driver):
         return self.title in driver.title

 class presence_of_element_located(object):
     """ An expectation for checking that an element is present on the DOM
     of a page. This does not necessarily mean that the element is visible.
     locator - used to find the element
     returns the WebElement once it is located
     """
     def __init__(self, locator):
         self.locator = locator

     def __call__(self, driver):
         return _find_element(driver, self.locator)

 class visibility_of_element_located(object):
     """ An expectation for checking that an element is present on the DOM of a
     page and visible. Visibility means that the element is not only displayed
     but also has a height and width that is greater than 0.
     locator - used to find the element
     returns the WebElement once it is located and visible
     """
     def __init__(self, locator):
         self.locator = locator

     def __call__(self, driver):
         try:
             return _element_if_visible(_find_element(driver, self.locator))
         except StaleElementReferenceException:
             return False

 class visibility_of(object):
     """ An expectation for checking that an element, known to be present on the
     DOM of a page, is visible. Visibility means that the element is not only
     displayed but also has a height and width that is greater than 0.
     element is the WebElement
     returns the (same) WebElement once it is visible
     """
     def __init__(self, element):
         self.element = element

     def __call__(self, ignored):
         return _element_if_visible(self.element)

 def _element_if_visible(element, visibility=True):
     return element if element.is_displayed() == visibility else False

 class presence_of_all_elements_located(object):
     """ An expectation for checking that there is at least one element present
     on a web page.
     locator is used to find the element
     returns the list of WebElements once they are located
     """
     def __init__(self, locator):
         self.locator = locator

     def __call__(self, driver):
         return _find_elements(driver, self.locator)

 class text_to_be_present_in_element(object):
     """ An expectation for checking if the given text is present in the
     specified element.
     locator, text
     """
     def __init__(self, locator, text_):
         self.locator = locator
         self.text = text_

     def __call__(self, driver):
         try :
             element_text = _find_element(driver, self.locator).text
             return self.text in element_text
         except StaleElementReferenceException:
             return False

 class text_to_be_present_in_element_value(object):
     """
     An expectation for checking if the given text is present in the element's
     locator, text
     """
     def __init__(self, locator, text_):
         self.locator = locator
         self.text = text_

     def __call__(self, driver):
         try:
             element_text = _find_element(driver,
                                          self.locator).get_attribute("value")
             if element_text:
                 return self.text in element_text
             else:
                 return False
         except StaleElementReferenceException:
                 return False

 class frame_to_be_available_and_switch_to_it(object):
     """ An expectation for checking whether the given frame is available to
     switch to.  If the frame is available it switches the given driver to the
     specified frame.
     """
     def __init__(self, locator):
         self.frame_locator = locator

     def __call__(self, driver):
         try:
             if isinstance(self.frame_locator, tuple):
                 driver.switch_to.frame(_find_element(driver,
                                                      self.frame_locator))
             else:
                 driver.switch_to.frame(self.frame_locator)
             return True
         except NoSuchFrameException:
             return False

 class invisibility_of_element_located(object):
     """ An Expectation for checking that an element is either invisible or not
     present on the DOM.

     locator used to find the element
     """
     def __init__(self, locator):
         self.locator = locator

     def __call__(self, driver):
         try:
             return _element_if_visible(_find_element(driver, self.locator), False)
         except (NoSuchElementException, StaleElementReferenceException):
             # In the case of NoSuchElement, returns true because the element is
             # not present in DOM. The try block checks if the element is present
             # but is invisible.
             # In the case of StaleElementReference, returns true because stale
             # element reference implies that element is no longer visible.
             return True

 class element_to_be_clickable(object):
     """ An Expectation for checking an element is visible and enabled such that
     you can click it."""
     def __init__(self, locator):
         self.locator = locator

     def __call__(self, driver):
         element = visibility_of_element_located(self.locator)(driver)
         if element and element.is_enabled():
             return element
         else:
             return False

 class staleness_of(object):
     """ Wait until an element is no longer attached to the DOM.
     element is the element to wait for.
     returns False if the element is still attached to the DOM, true otherwise.
     """
     def __init__(self, element):
         self.element = element

     def __call__(self, ignored):
         try:
             # Calling any method forces a staleness check
             self.element.is_enabled()
             return False
         except StaleElementReferenceException as expected:
             return True

 class element_to_be_selected(object):
     """ An expectation for checking the selection is selected.
     element is WebElement object
     """
     def __init__(self, element):
         self.element = element

     def __call__(self, ignored):
         return self.element.is_selected()

 class element_located_to_be_selected(object):
     """An expectation for the element to be located is selected.
     locator is a tuple of (by, path)"""
     def __init__(self, locator):
         self.locator = locator

     def __call__(self, driver):
         return _find_element(driver, self.locator).is_selected()

 class element_selection_state_to_be(object):
     """ An expectation for checking if the given element is selected.
     element is WebElement object
     is_selected is a Boolean."
     """
     def __init__(self, element, is_selected):
         self.element = element
         self.is_selected = is_selected

     def __call__(self, ignored):
         return self.element.is_selected() == self.is_selected

 class element_located_selection_state_to_be(object):
     """ An expectation to locate an element and check if the selection state
     specified is in that state.
     locator is a tuple of (by, path)
     is_selected is a boolean
     """
     def __init__(self, locator, is_selected):
         self.locator = locator
         self.is_selected = is_selected

     def __call__(self, driver):
         try:
             element = _find_element(driver, self.locator)
             return element.is_selected() == self.is_selected
         except StaleElementReferenceException:
             return False

 class alert_is_present(object):
     """ Expect an alert to be present."""
     def __init__(self):
         pass

     def __call__(self, driver):
         try:
             alert = driver.switch_to.alert
             alert.text
             return alert
         except NoAlertPresentException:
             return False

 def _find_element(driver, by):
     """Looks up an element. Logs and re-raises ``WebDriverException``
     if thrown."""
     try :
         return driver.find_element(*by)
     except NoSuchElementException as e:
         raise e
     except WebDriverException as e:
         raise e

 def _find_elements(driver, by):
     try :
         return driver.find_elements(*by)
     except WebDriverException as e:
         raise e

哈哈，我相信这个py文件大家一看就能懂。这无非就是一些预期条件。

结合上面的WebDriverWait，我们可以这么用：

from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

'''
10秒钟等待浏览器弹出的对话框，如果出现，就点击确定按钮
'''
WebDriverWait(chromedriver,10).until(EC.alert_is_present()).accept()

我们的自动化脚本跑得快慢或者出现异常，很大程度上取决于我们设定的等待时间，如果你还是习惯于time.sleep(5)这种方式的话，这将会浪费很多时间。
根据expected_conditions.py文件的写法，我们也可以定义一些自己的期待类，例如：

from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class must_get_url(object):
    '''
    必须到达的URL
       参数：
       url    - 必须到达的地址
    '''
    def __init__(self, url):
        self.url = url

    def __call__(self, driver):
        driver.get(self.url)
        return self.url == driver.current_url

options = webdriver.ChromeOptions()
options.add_argument("--test-type")
chromedriver =     webdriver.Chrome(r"E:\MyProject\WebDriver\chromedriver.exe",chrome_options=options)
WebDriverWait(chromedriver,10).until(must_get_url("https://www.baidu.com"))