__init__.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.
 
from collections import namedtuple
from inspect import isclass
 
from robot.api import logger
from robot.errors import DataError
from robot.libraries.BuiltIn import BuiltIn
from robot.utils.importer import Importer
 
from SeleniumLibrary.base import DynamicCore, LibraryComponent
from SeleniumLibrary.errors import NoOpenBrowser, PluginError
from SeleniumLibrary.keywords import (AlertKeywords,
                                      BrowserManagementKeywords,
                                      CookieKeywords,
                                      ElementKeywords,
                                      FormElementKeywords,
                                      FrameKeywords,
                                      JavaScriptKeywords,
                                      RunOnFailureKeywords,
                                      ScreenshotKeywords,
                                      SelectElementKeywords,
                                      TableElementKeywords,
                                      WaitingKeywords,
                                      WebDriverCache,
                                      WindowKeywords)
from SeleniumLibrary.locators import ElementFinder
from SeleniumLibrary.utils import LibraryListener, timestr_to_secs, is_truthy
 
 
__version__ = '4.0.0a2.dev1'
 
 
 
class SeleniumLibrary(DynamicCore):
    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
    ROBOT_LIBRARY_VERSION = __version__
 
    
    def __init__(self, timeout=5.0, implicit_wait=0.0,
                 run_on_failure='Capture Page Screenshot',
                 screenshot_root_directory=None, plugins=None,
                 event_firing_webdriver=None):
        self.timeouttimeout = timestr_to_secs(timeout)
        self.implicit_waitimplicit_wait = timestr_to_secs(implicit_wait)
        self.speedspeed = 0.0
        self.run_on_failure_keyword \
            = RunOnFailureKeywords.resolve_keyword(run_on_failure)
        self._running_on_failure_keyword_running_on_failure_keyword = False
        self.screenshot_root_directoryscreenshot_root_directory = screenshot_root_directory
        self._element_finder_element_finder = ElementFinder(self)
        self._plugin_keywords_plugin_keywords = []
        libraries = [
            AlertKeywords(self),
            BrowserManagementKeywords(self),
            CookieKeywords(self),
            ElementKeywords(self),
            FormElementKeywords(self),
            FrameKeywords(self),
            JavaScriptKeywords(self),
            RunOnFailureKeywords(self),
            ScreenshotKeywords(self),
            SelectElementKeywords(self),
            TableElementKeywords(self),
            WaitingKeywords(self),
            WindowKeywords(self)
        ]
        if is_truthy(plugins):
            plugin_libs = self._parse_plugins_parse_plugins(plugins)
            libraries = libraries + plugin_libs
        self._drivers_drivers = WebDriverCache()
        DynamicCore.__init__(self, libraries)
        self.ROBOT_LIBRARY_LISTENERROBOT_LIBRARY_LISTENER = LibraryListener()
        if is_truthy(event_firing_webdriver):
            self.event_firing_webdriverevent_firing_webdriver = self._parse_listener_parse_listener(event_firing_webdriver)
        else:
            self.event_firing_webdriverevent_firing_webdriver = None
 
    def run_keyword(self, name, args, kwargs):
        try:
            return DynamicCore.run_keyword(self, name, args, kwargs)
        except Exception:
            self.failure_occurredfailure_occurred()
            raise
 
    def get_keyword_tags(self, name):
        tags = list(DynamicCore.get_keyword_tags(self, name))
        if name in self._plugin_keywords_plugin_keywords:
            tags.append('plugin')
        return tags
 
    
    def register_driver(self, driver, alias):
        return self._drivers_drivers.register(driver, alias)
 
    
    def failure_occurred(self):
        if self._running_on_failure_keyword_running_on_failure_keyword or not self.run_on_failure_keyword:
            return
        try:
            self._running_on_failure_keyword_running_on_failure_keyword = True
            BuiltIn().run_keyword(self.run_on_failure_keyword)
        except Exception as err:
            logger.warn("Keyword '%s' could not be run on failure: %s"
                        % (self.run_on_failure_keyword, err))
        finally:
            self._running_on_failure_keyword_running_on_failure_keyword = False
 
    @property
    
    driver = property
    
    def driver(self):
        if not self._drivers_drivers.current:
            raise NoOpenBrowser('No browser is open.')
        return self._drivers_drivers.current
 
    
    def find_element(self, locator, parent=None):
        return self._element_finder_element_finder.find(locator, parent=parent)
 
    
    def find_elements(self, locator, parent=None):
        return self._element_finder_element_finder.find(locator, first_only=False,
                                         required=False, parent=parent)
 
    def _parse_plugins(self, plugins):
        libraries = []
        importer = Importer('test library')
        for parsed_plugin in self._string_to_modules_string_to_modules(plugins):
            plugin = importer.import_class_or_module(parsed_plugin.module)
            if not isclass(plugin):
                message = "Importing test library: '%s' failed." % parsed_plugin.module
                raise DataError(message)
            plugin = plugin(self, *parsed_plugin.args,
                            **parsed_plugin.kw_args)
            if not isinstance(plugin, LibraryComponent):
                message = 'Plugin does not inherit SeleniumLibrary.base.LibraryComponent'
                raise PluginError(message)
            self._store_plugin_keywords_store_plugin_keywords(plugin)
            libraries.append(plugin)
        return libraries
 
    def _parse_listener(self, event_firing_webdriver):
        listener_module = self._string_to_modules_string_to_modules(event_firing_webdriver)
        listener_count = len(listener_module )
        if listener_count > 1:
            message = 'Is is possible import only one listener but there was %s listeners.' % listener_count
            raise ValueError(message)
        listener_module = listener_module[0]
        importer = Importer('test library')
        listener = importer.import_class_or_module(listener_module.module)
        if not isclass(listener):
            message = "Importing test Selenium lister class '%s' failed." % listener_module.module
            raise DataError(message)
        return listener
 
    def _string_to_modules(self, modules):
        Module = namedtuple('Module', 'module, args, kw_args')
        parsed_modules = []
        for module in modules.split(','):
            module = module.strip()
            module_and_args = module.split(';')
            module_name = module_and_args.pop(0)
            kw_args = {}
            args = []
            for argument in module_and_args:
                if '=' in argument:
                    key, value = argument.split('=')
                    kw_args[key] = value
                else:
                    args.append(argument)
            module = Module(module=module_name, args=args, kw_args=kw_args)
            parsed_modules.append(module)
        return parsed_modules
 
    def _store_plugin_keywords(self, plugin):
        dynamic_core = DynamicCore([plugin])
        self._plugin_keywords_plugin_keywords.extend(dynamic_core.get_keyword_names())