browsermanagement.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
import types
 
from selenium import webdriver
from selenium.webdriver.support.event_firing_webdriver import EventFiringWebDriver
 
from SeleniumLibrary.base import keyword, LibraryComponent
from SeleniumLibrary.locators import WindowManager
from SeleniumLibrary.utils import (is_truthy, is_noney, secs_to_timestr,
                                   timestr_to_secs)
 
from .webdrivertools import WebDriverCreator
 
 
class BrowserManagementKeywords(LibraryComponent):
 
    def __init__(self, ctx):
        LibraryComponent.__init__(self, ctx)
        self._window_manager_window_manager = WindowManager(ctx)
 
    @keyword
    
    def close_all_browsers(self):
        self.debugdebug('Closing all browsers.')
        self.driversdriversdrivers.close_all()
 
    @keyword
    
    def close_browser(self):
        if self.driversdriversdrivers.current:
            self.debugdebug('Closing browser with session id {}.'
                       .format(self.driverdriverdriver.session_id))
            self.driversdriversdrivers.close()
 
    @keyword
    
    def open_browser(self, url, browser='firefox', alias=None,
                     remote_url=False, desired_capabilities=None,
                     ff_profile_dir=None, service_log_path=None):
        index = self.driversdriversdrivers.get_index(alias)
        if index:
            self.infoinfo('Using existing browser from index %s.' % index)
            self.switch_browserswitch_browser(alias)
            self.go_togo_to(url)
            return index
        return self._make_new_browser_make_new_browser(url, browser, alias, remote_url,
                                      desired_capabilities, ff_profile_dir,
                                      service_log_path)
 
    def _make_new_browser(self, url, browser='firefox', alias=None,
                          remote_url=False, desired_capabilities=None,
                          ff_profile_dir=None, service_log_path=None):
        if is_truthy(remote_url):
            self.infoinfo("Opening browser '%s' to base url '%s' through "
                      "remote server at '%s'." % (browser, url, remote_url))
        else:
            self.infoinfo("Opening browser '%s' to base url '%s'." % (browser, url))
        driver = self._make_driver_make_driver(browser, desired_capabilities,
                                   ff_profile_dir, remote_url,
                                   service_log_path)
        driver = self._wrap_event_firing_webdriver_wrap_event_firing_webdriver(driver)
        try:
            driver.get(url)
        except Exception:
            self.ctxctx.register_driver(driver, alias)
            self.debugdebug("Opened browser with session id %s but failed "
                       "to open url '%s'." % (driver.session_id, url))
            raise
        self.debugdebug('Opened browser with session id %s.' % driver.session_id)
        return self.ctxctx.register_driver(driver, alias)
 
    @keyword
    
    def create_webdriver(self, driver_name, alias=None, kwargs={},
                         **init_kwargs):
        if not isinstance(kwargs, dict):
            raise RuntimeError("kwargs must be a dictionary.")
        for arg_name in kwargs:
            if arg_name in init_kwargs:
                raise RuntimeError("Got multiple values for argument '%s'." % arg_name)
            init_kwargs[arg_name] = kwargs[arg_name]
        driver_name = driver_name.strip()
        try:
            creation_func = getattr(webdriver, driver_name)
        except AttributeError:
            raise RuntimeError("'%s' is not a valid WebDriver name." % driver_name)
        self.infoinfo("Creating an instance of the %s WebDriver." % driver_name)
        driver = creation_func(**init_kwargs)
        self.debugdebug("Created %s WebDriver instance with session id %s."
                   % (driver_name, driver.session_id))
        driver = self._wrap_event_firing_webdriver_wrap_event_firing_webdriver(driver)
        return self.ctxctx.register_driver(driver, alias)
 
    def _wrap_event_firing_webdriver(self, driver):
        if not self.ctxctx.event_firing_webdriver:
            return driver
        self.debugdebug('Wrapping driver to event_firing_webdriver.')
        return EventFiringWebDriver(driver, self.ctxctx.event_firing_webdriver())
 
    @keyword
    
    def switch_browser(self, index_or_alias):
        try:
            self.driversdriversdrivers.switch(index_or_alias)
        except RuntimeError:
            raise RuntimeError("No browser with index or alias '%s' found."
                               % index_or_alias)
        self.debugdebug('Switched to browser with Selenium session id %s.'
                   % self.driverdriverdriver.session_id)
 
    @keyword
    
    def get_session_id(self):
        return self.driverdriverdriver.session_id
 
    @keyword
    
    def get_source(self):
        return self.driverdriverdriver.page_source
 
    @keyword
    
    def get_title(self):
        return self.driverdriverdriver.title
 
    @keyword
    
    def get_location(self):
        return self.driverdriverdriver.current_url
 
    @keyword
    
    def location_should_be(self, url, message=None):
        actual = self.get_locationget_location()
        if actual != url:
            if is_noney(message):
                message = ("Location should have been '%s' but "
                           "was '%s'." % (url, actual))
            raise AssertionError(message)
        self.infoinfo("Current location is '%s'." % url)
 
    @keyword
    
    def location_should_contain(self, expected, message=None):
        actual = self.get_locationget_location()
        if expected not in actual:
            if is_noney(message):
                message = ("Location should have contained '%s' but "
                           "it was '%s'." % (expected, actual))
            raise AssertionError(message)
        self.infoinfo("Current location contains '%s'." % expected)
 
    @keyword
    
    def log_location(self):
        url = self.get_locationget_location()
        self.infoinfo(url)
        return url
 
    @keyword
    
    def log_source(self, loglevel='INFO'):
        source = self.get_sourceget_source()
        self.loglog(source, loglevel)
        return source
 
    @keyword
    
    def log_title(self):
        title = self.get_titleget_title()
        self.infoinfo(title)
        return title
 
    @keyword
    
    def title_should_be(self, title, message=None):
        actual = self.get_titleget_title()
        if actual != title:
            if is_noney(message):
                message = "Title should have been '%s' but was '%s'." % (title, actual)
            raise AssertionError(message)
        self.infoinfo("Page title is '%s'." % title)
 
    @keyword
    
    def go_back(self):
        self.driverdriverdriver.back()
 
    @keyword
    
    def go_to(self, url):
        self.infoinfo("Opening url '%s'" % url)
        self.driverdriverdriver.get(url)
 
    @keyword
    
    def reload_page(self):
        self.driverdriverdriver.refresh()
 
    @keyword
    
    def get_selenium_speed(self):
        return secs_to_timestr(self.ctxctx.speed)
 
    @keyword
    
    def get_selenium_timeout(self):
        return secs_to_timestr(self.ctxctx.timeout)
 
    @keyword
    
    def get_selenium_implicit_wait(self):
        return secs_to_timestr(self.ctxctx.implicit_wait)
 
    @keyword
    
    def set_selenium_speed(self, value):
        old_speed = self.get_selenium_speedget_selenium_speed()
        self.ctxctx.speed = timestr_to_secs(value)
        for driver in self.driversdriversdrivers.active_drivers:
            self._monkey_patch_speed_monkey_patch_speed(driver)
        return old_speed
 
    @keyword
    
    def set_selenium_timeout(self, value):
        old_timeout = self.get_selenium_timeoutget_selenium_timeout()
        self.ctxctx.timeout = timestr_to_secs(value)
        for driver in self.driversdriversdrivers.active_drivers:
            driver.set_script_timeout(self.ctxctx.timeout)
        return old_timeout
 
    @keyword
    
    def set_selenium_implicit_wait(self, value):
        old_wait = self.get_selenium_implicit_waitget_selenium_implicit_wait()
        self.ctxctx.implicit_wait = timestr_to_secs(value)
        for driver in self.driversdriversdrivers.active_drivers:
            driver.implicitly_wait(self.ctxctx.implicit_wait)
        return old_wait
 
    @keyword
    
    def set_browser_implicit_wait(self, value):
        self.driverdriverdriver.implicitly_wait(timestr_to_secs(value))
 
    def _make_driver(self, browser, desired_capabilities=None,
                     profile_dir=None, remote=None, service_log_path=None):
        driver = WebDriverCreator(self.log_dirlog_dirlog_dir).create_driver(
            browser=browser, desired_capabilities=desired_capabilities,
            remote_url=remote, profile_dir=profile_dir, service_log_path=service_log_path)
        driver.set_script_timeout(self.ctxctx.timeout)
        driver.implicitly_wait(self.ctxctx.implicit_wait)
        if self.ctxctx.speed:
            self._monkey_patch_speed_monkey_patch_speed(driver)
        return driver
 
    def _monkey_patch_speed(self, driver):
        def execute(self, driver_command, params=None):
            result = self._base_execute(driver_command, params)
            speed = self._speed if hasattr(self, '_speed') else 0.0
            if speed > 0:
                time.sleep(speed)
            return result
        if not hasattr(driver, '_base_execute'):
            driver._base_execute = driver.execute
            driver.execute = types.MethodType(execute, driver)
        driver._speed = self.ctxctx.speed