waiting.py

Go to the documentation of this file.

# Copyright 2008-2011 Nokia Networks
# Copyright 2011-2016 Ryan Tomac, Ed Manlove and contributors
# Copyright 2016-     Robot Framework Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
 
import time
 
from selenium.common.exceptions import StaleElementReferenceException
 
from SeleniumLibrary.base import LibraryComponent, keyword
from SeleniumLibrary.errors import ElementNotFound
from SeleniumLibrary.utils import is_noney, secs_to_timestr
 
 
class WaitingKeywords(LibraryComponent):
 
    @keyword
    
    def wait_for_condition(self, condition, timeout=None, error=None):
        if 'return' not in condition:
            raise ValueError("Condition '%s' did not have mandatory 'return'."
                             % condition)
        self._wait_until_wait_until(
            lambda: self.driverdriverdriver.execute_script(condition) is True,
            "Condition '%s' did not become true in <TIMEOUT>." % condition,
            timeout, error
        )
 
    @keyword
    
    def wait_until_location_is(self, expected, timeout=None, message=None):
 
        expected = str(expected)
        self._wait_until_wait_until(lambda: expected == self.driverdriverdriver.current_url,
                         "Location did not is '%s' in <TIMEOUT>." % expected,
                         timeout, message)
 
    @keyword
    
    def wait_until_location_contains(self, expected, timeout=None, message=None):
        expected = str(expected)
        self._wait_until_wait_until(lambda: expected in self.driverdriverdriver.current_url,
                         "Location did not contain '%s' in <TIMEOUT>." % expected,
                         timeout, message)
 
 
    @keyword
    
    def wait_until_page_contains(self, text, timeout=None, error=None):
        self._wait_until_wait_until(lambda: self.is_text_presentis_text_present(text),
                         "Text '%s' did not appear in <TIMEOUT>." % text,
                         timeout, error)
 
    @keyword
    
    def wait_until_page_does_not_contain(self, text, timeout=None,
                                         error=None):
        self._wait_until_wait_until(lambda: not self.is_text_presentis_text_present(text),
                         "Text '%s' did not disappear in <TIMEOUT>." % text,
                         timeout, error)
 
    @keyword
    
    def wait_until_page_contains_element(self, locator, timeout=None,
                                         error=None):
        self._wait_until_wait_until(
            lambda: self.find_elementfind_element(locator, required=False) is not None,
            "Element '%s' did not appear in <TIMEOUT>." % locator,
            timeout, error
        )
 
    @keyword
    
    def wait_until_page_does_not_contain_element(self, locator, timeout=None,
                                                 error=None):
        self._wait_until_wait_until(
            lambda: self.find_elementfind_element(locator, required=False) is None,
            "Element '%s' did not disappear in <TIMEOUT>." % locator,
            timeout, error
        )
 
    @keyword
    
    def wait_until_element_is_visible(self, locator, timeout=None,
                                      error=None):
        self._wait_until_wait_until(
            lambda: self.is_visibleis_visible(locator),
            "Element '%s' not visible after <TIMEOUT>." % locator,
            timeout, error
        )
 
    @keyword
    
    def wait_until_element_is_not_visible(self, locator, timeout=None,
                                          error=None):
        self._wait_until_wait_until(
            lambda: not self.is_visibleis_visible(locator),
            "Element '%s' still visible after <TIMEOUT>." % locator,
            timeout, error
        )
 
    @keyword
    
    def wait_until_element_is_enabled(self, locator, timeout=None,
                                      error=None):
        self._wait_until_wait_until(
            lambda: self.is_element_enabledis_element_enabled(locator),
            "Element '%s' was not enabled in <TIMEOUT>." % locator,
            timeout, error
        )
 
    @keyword
    
    def wait_until_element_contains(self, locator, text, timeout=None,
                                    error=None):
        self._wait_until_wait_until(
            lambda: text in self.find_elementfind_element(locator).text,
            "Element '%s' did not get text '%s' in <TIMEOUT>." % (locator, text),
            timeout, error
        )
 
    @keyword
    
    def wait_until_element_does_not_contain(self, locator, text, timeout=None,
                                            error=None):
        self._wait_until_wait_until(
            lambda: text not in self.find_elementfind_element(locator).text,
            "Element '%s' still had text '%s' after <TIMEOUT>." % (locator, text),
            timeout, error
        )
 
    def _wait_until(self, condition, error, timeout=None, custom_error=None):
        timeout = self.get_timeoutget_timeout(timeout)
        if is_noney(custom_error):
            error = error.replace('<TIMEOUT>', secs_to_timestr(timeout))
        else:
            error = custom_error
        self._wait_until_worker_wait_until_worker(condition, timeout, error)
 
    def _wait_until_worker(self, condition, timeout, error):
        max_time = time.time() + timeout
        not_found = None
        while time.time() < max_time:
            try:
                if condition():
                    return
            except ElementNotFound as err:
                not_found = str(err)
            except StaleElementReferenceException as err:
                self.infoinfo('Suppressing StaleElementReferenceException from Selenium.')
                not_found = err
            else:
                not_found = None
            time.sleep(0.2)
        raise AssertionError(not_found or error)