| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import time |
| |
| from selenium.common.exceptions import NoSuchElementException |
| from selenium.common.exceptions import TimeoutException as \ |
| SeleniumTimeoutException |
| from selenium.common.exceptions import WebDriverException |
| from selenium.webdriver.support.ui import WebDriverWait |
| |
| class WebDriverCoreHelpers(object): |
| """Base class for manipulating web pages using webdriver.""" |
| |
| def __init__(self): |
| super(WebDriverCoreHelpers, self).__init__() |
| self.driver = None |
| self.wait = WebDriverWait(self.driver, timeout=5) |
| |
| |
| def _check_for_alert_in_message(self, message, alert_handler): |
| """Check for an alert in error message and handle it. |
| |
| @param message: The error message. |
| @param alert_handler: The handler method to call. |
| |
| """ |
| if (message.find('An open modal dialog blocked') != -1 and |
| message.find('unexpected alert open') != -1): |
| alert = self.driver.switch_to_alert() |
| alert_handler(alert) |
| else: |
| raise RuntimeError(message) |
| |
| |
| def _handle_alert(self, xpath, alert_handler): |
| """Calls the alert handler if there is an alert. |
| |
| @param xpath: The xpath that could raise the alert. |
| @param alert_handler: the handler method to call. |
| |
| """ |
| try: |
| self.driver.find_element_by_xpath(xpath) |
| return |
| except WebDriverException, e: |
| message = str(e) |
| # The messages differ based on the webdriver version |
| if (message.find('An open modal dialog blocked') == -1 and |
| message.find('unexpected alert open') == -1): |
| return |
| self._handler(alert_handler) |
| # Sometimes routers put out multiple alert statements on the same page. |
| self._handle_alert(xpath, alert_handler) |
| |
| |
| def _handler(self, alert_handler): |
| """Handles the alert. |
| |
| @param alert_handler: The custom handler method to call. |
| |
| """ |
| alert = self.driver.switch_to_alert() |
| if not alert_handler: |
| # The caller did not provide us with a handler, dismiss and raise. |
| try: |
| alert_text = alert.text |
| except WebDriverException: |
| # There is a bug in selenium where the alert object will exist |
| # but you can't get to the text object right away. |
| time.sleep(1) |
| alert_text = alert.text |
| alert.accept() |
| raise RuntimeError('An alert was encountered and no handler was ' |
| 'specified. The text from the alert was: %s' |
| % alert_text) |
| alert_handler(alert) |
| |
| |
| def set_wait_time(self, time): |
| """Sets the wait time of webdriver commands. |
| |
| @param time: the time to wait in seconds. |
| |
| """ |
| self.wait = WebDriverWait(self.driver, timeout=time) |
| |
| |
| def restore_default_wait_time(self): |
| """Restores the default webdriver wait time.""" |
| self.wait = WebDriverWait(self.driver, timeout=5) |
| |
| |
| def wait_for_objects_by_id(self, element_ids, wait_time=5): |
| """Wait for one of the element_ids to show up. |
| |
| @param element_ids: A list of all the element ids to find. |
| @param wait_time: The time to wait before giving up. |
| |
| @return The id that was found first. |
| |
| """ |
| xpaths = [] |
| for element_id in element_ids: |
| xpaths.append('id("%s")' % element_id) |
| xpath_found = self.wait_for_objects_by_xpath(xpaths, wait_time) |
| for element_id in element_ids: |
| if element_id in xpath_found: |
| return element_id |
| |
| |
| def wait_for_objects_by_xpath(self, xpaths, wait_time=5): |
| """Wait for one of the items in the xpath to show up. |
| |
| @param xpaths: A list of all the xpath's of elements to find. |
| @param wait_time: The time to wait before giving up. |
| |
| @return The xpath that was found first. |
| |
| """ |
| excpetion = None |
| if wait_time < len(xpaths): |
| wait_time = len(xpaths) |
| start_time = int(time.time()) |
| while (int(time.time()) - start_time) < wait_time: |
| for xpath in xpaths: |
| try: |
| element = self.wait_for_object_by_xpath(xpath, |
| wait_time=0.25) |
| if element and element.is_displayed(): |
| return xpath |
| except SeleniumTimeoutException, e: |
| exception = str(e) |
| pass |
| raise SeleniumTimeoutException(exception) |
| |
| |
| def click_button_by_id(self, element_id, alert_handler=None): |
| """Clicks a button by id. |
| |
| @param element_id: the id of the button |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| return self.click_button_by_xpath(xpath, alert_handler) |
| |
| |
| def click_button_by_xpath(self, xpath, alert_handler=None): |
| """Clicks a button by xpath. |
| |
| @param xpath: the xpath of the button |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| """ |
| button = self.wait_for_object_by_xpath(xpath) |
| button.click() |
| self._handle_alert(xpath, alert_handler) |
| |
| |
| def get_url(self, page_url, page_title=None, element_xpath=None): |
| """Load page and check if the page loads completely, if not, reload. |
| |
| @param page_url: The url to load. |
| @param page_title: The complete/partial title of the page after loaded. |
| @param element_xpath: The element that we search for to confirm that |
| the page loaded. |
| |
| """ |
| self.driver.get(page_url) |
| if page_title: |
| try: |
| self.wait.until(lambda _: page_title in self.driver.title) |
| except SeleniumTimeoutException, e: |
| self.driver.get(page_url) |
| self.wait.until(lambda _: self.driver.title) |
| finally: |
| if not page_title in self.driver.title: |
| raise WebDriverException('Page did not load. Expected %s in' |
| 'title, but got %s as title.' % |
| (page_title, self.driver.title)) |
| if element_xpath: |
| self.wait_for_object_by_xpath(element_xpath) |
| |
| |
| def wait_for_object_by_id(self, element_id, wait_time=5): |
| """Waits for an element to become available; returns a reference to it. |
| |
| @param element_id: the id of the element to wait for |
| @param wait_time: the time to wait for the object |
| |
| @returns a reference to the element if found before a timeout. |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| return self.wait_for_object_by_xpath(xpath, wait_time=wait_time) |
| |
| |
| def wait_for_object_by_xpath_to_vanish(self, xpath, wait_time=5): |
| """Wait for the item in xpath to disappear from page. |
| |
| @param xpath: The xpath of the object to wait on. |
| @param wait_time: The time to wait before giving up. |
| |
| @return void or raise exception if object does not vanish. |
| |
| """ |
| start_time = int(time.time()) |
| while (int(time.time()) - start_time) < wait_time: |
| if self.object_by_xpath_exist(xpath): |
| time.sleep(0.5) |
| else: |
| return |
| raise SeleniumTimeoutException('The object with xpath %s failed to' |
| ' vanish.' % xpath) |
| |
| |
| def wait_for_object_by_id_to_vanish(self, element_id, wait_time=5): |
| """Wait for the item in xpath to disappear from page. |
| |
| @param element_id: The id of the object to wait on. |
| @param wait_time: The time to wait before giving up. |
| |
| @return void or raise exception if object does not vanish. |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| return self.wait_for_object_by_xpath_to_vanish(xpath, |
| wait_time=wait_time) |
| |
| |
| def object_by_id_exist(self, element_id): |
| """Finds if an object exist in this particular page. |
| |
| @param element_id: the id of the element to find |
| |
| @returns True if the element exists. False if the element does not. |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| return self.object_by_xpath_exist(xpath) |
| |
| |
| def object_by_xpath_exist(self, xpath): |
| """Finds if an object exist in this particular page. |
| |
| @param xpath: the xpath of the element to find |
| |
| @returns True if the xpath exists. False if the xpath does not. |
| |
| """ |
| try: |
| self.wait_for_object_by_xpath(xpath) |
| except SeleniumTimeoutException: |
| return False |
| return True |
| |
| |
| def wait_for_object_by_xpath(self, xpath, wait_time=5): |
| """Waits for an element to become available; returns a reference to it. |
| |
| @param xpath: the xpath of the element to wait for |
| @param wait_time: the time to wait for the object. |
| |
| @returns reference to the element if found before a timeout. |
| |
| """ |
| self.set_wait_time(wait_time) |
| try: |
| self.wait.until(lambda _: self.driver.find_element_by_xpath(xpath)) |
| element = self.driver.find_element_by_xpath(xpath) |
| except (SeleniumTimeoutException, NoSuchElementException) as e: |
| self.restore_default_wait_time() |
| raise SeleniumTimeoutException('Unable to find the object by ' |
| 'xpath: %s\n WebDriver exception: ' |
| '%s' % (xpath, str(e))) |
| self.restore_default_wait_time() |
| return element |
| |
| |
| def item_in_popup_by_id_exist(self, item, element_id): |
| """Returns if an item exists in a popup given a id |
| |
| @param item: name of the item |
| @param element_id: the id of the popup |
| |
| @returns True if the item exists; False otherwise. |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| return self.item_in_popup_by_xpath_exist(item, xpath) |
| |
| |
| def item_in_popup_by_xpath_exist(self, item, xpath): |
| """Returns if an item exists in a popup given an xpath |
| |
| @param item: name of the item |
| @param xpath: the xpath of the popup |
| |
| @returns True if the item exists; False otherwise. |
| |
| """ |
| if self.number_of_items_in_popup_by_xpath(xpath) == 0: |
| raise SeleniumTimeoutException('The popup at xpath %s has no items.' |
| % xpath) |
| popup = self.driver.find_element_by_xpath(xpath) |
| for option in popup.find_elements_by_tag_name('option'): |
| if option.text == item: |
| return True |
| return False |
| |
| |
| def number_of_items_in_popup_by_id(self, element_id, alert_handler=None): |
| """Returns the number of items in a popup given the element ID. |
| |
| @param element_id: the html ID of the item |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| @returns the number of items in the popup. |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| return self.number_of_items_in_popup_by_xpath(xpath, alert_handler) |
| |
| |
| def number_of_items_in_popup_by_xpath(self, xpath, alert_handler=None): |
| """Returns the number of items in a popup given a xpath |
| |
| @param xpath: the xpath of the popup |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| @returns the number of items in the popup. |
| |
| """ |
| popup = self.driver.find_element_by_xpath(xpath) |
| try: |
| self.wait.until(lambda _: |
| len(popup.find_elements_by_tag_name('option'))) |
| except SeleniumTimeoutException, e: |
| return 0 |
| return len(popup.find_elements_by_tag_name('option')) |
| |
| |
| def select_item_from_popup_by_id(self, item, element_id, |
| wait_for_xpath=None, alert_handler=None): |
| """Selects an item from a popup, by passing the element ID. |
| |
| @param item: the string of the item to select from the popup |
| @param element_id: the html ID of the item |
| @param wait_for_xpath: an item to wait for before returning, if not |
| specified the method does not wait. |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| """ |
| xpath = 'id("%s")' % element_id |
| self.select_item_from_popup_by_xpath(item, xpath, wait_for_xpath, |
| alert_handler) |
| |
| |
| def select_item_from_popup_by_xpath(self, item, xpath, wait_for_xpath=None, |
| alert_handler=None): |
| """Selects an item from a popup, by passing the xpath of the popup. |
| |
| @param item: the string of the item to select from the popup |
| @param xpath: the xpath of the popup |
| @param wait_for_xpath: an item to wait for before returning, if not |
| specified the method does not wait. |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| """ |
| if self.number_of_items_in_popup_by_xpath(xpath) == 0: |
| raise SeleniumTimeoutException('The popup at xpath %s has no items.' |
| % xpath) |
| if not self.item_in_popup_by_xpath_exist(item, xpath): |
| raise SeleniumTimeoutException('The popup at xpath %s does not ' |
| 'contain the item %s.' % (xpath, |
| item)) |
| popup = self.driver.find_element_by_xpath(xpath) |
| for option in popup.find_elements_by_tag_name('option'): |
| if option.text == item: |
| option.click() |
| break |
| self._handle_alert(xpath, alert_handler) |
| if wait_for_xpath: |
| self.wait_for_object_by_xpath(wait_for_xpath) |
| |
| |
| def set_content_of_text_field_by_id(self, content, text_field_id, |
| wait_for_xpath=None, |
| abort_check=False): |
| """Sets the content of a textfield, by passing the element ID. |
| |
| @param content: the content to apply to the textfield |
| @param text_field_id: the html ID of the textfield |
| @param wait_for_xpath: an item to wait for before returning, if not |
| specified the method does not wait. |
| |
| """ |
| xpath = 'id("%s")' % text_field_id |
| self.set_content_of_text_field_by_xpath(content, xpath, |
| wait_for_xpath=wait_for_xpath, |
| abort_check=abort_check) |
| |
| |
| def set_content_of_text_field_by_xpath(self, content, xpath, |
| wait_for_xpath=None, |
| abort_check=False): |
| """Sets the content of a textfield, by passing the xpath. |
| |
| @param content: the content to apply to the textfield |
| @param xpath: the xpath of the textfield |
| @param wait_for_xpath: an item to wait for before returning, if not |
| specified the method does not wait. |
| @param abort_check: do not get the current value before setting |
| |
| """ |
| # When we can get the value we know the text field is ready. |
| text_field = self.driver.find_element_by_xpath(xpath) |
| if text_field.get_attribute('type') != 'password' and not abort_check: |
| try: |
| self.wait.until(lambda _: text_field.get_attribute('value')) |
| except SeleniumTimeoutException, e: |
| raise SeleniumTimeoutException('Unable to obtain the value of ' |
| 'the text field %s.\nWebDriver ' |
| 'exception:%s' % (xpath, str(e))) |
| text_field.clear() |
| text_field.send_keys(content) |
| if wait_for_xpath: self.wait_for_object_by_xpath(wait_for_xpath) |
| |
| |
| def set_check_box_selected_by_id(self, check_box_id, selected=True, |
| wait_for_xpath=None, alert_handler=None): |
| """Sets the state of a checkbox, by passing the ID. |
| |
| @param check_box_id: the html id of the checkbox |
| @param selected: True to check the checkbox; False to uncheck it |
| @param wait_for_xpath: an item to wait for before returning, if not |
| specified the method does not wait. |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| |
| """ |
| xpath = 'id("%s")' % check_box_id |
| self.set_check_box_selected_by_xpath(xpath, selected, wait_for_xpath, |
| alert_handler) |
| |
| |
| def set_check_box_selected_by_xpath(self, xpath, selected=True, |
| wait_for_xpath=None, |
| alert_handler=None): |
| """Sets the state of a checkbox, by passing the xpath. |
| |
| @param xpath: the xpath of the checkbox |
| @param selected: True to check the checkbox; False to uncheck it |
| @param wait_for_xpath: an item to wait for before returning, if not |
| specified the method does not wait. |
| @param alert_handler: method invoked if an alert is detected. The method |
| must take one parameter, a webdriver alert object |
| """ |
| check_box = self.wait_for_object_by_xpath(xpath) |
| value = check_box.get_attribute('value') |
| if (value == '1' and not selected) or (value == '0' and selected): |
| check_box.click() |
| self._handle_alert(xpath, alert_handler) |
| if wait_for_xpath: |
| self.wait_for_object_by_xpath(wait_for_xpath) |
