Webdriver factory 2

src/SeleniumLibrary/keywords/__init__.py

@@ -26,4 +26,5 @@
 from .selectelement import SelectElementKeywords
 from .tableelement import TableElementKeywords
 from .waiting import WaitingKeywords
+from .webdrivercreator import WebDriverCreator
 from .window import WindowKeywords

src/SeleniumLibrary/keywords/browsermanagement.py

@@ -14,40 +14,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os.path
 import time
 import types
 
-from robot.utils import NormalizedDict
 from selenium import webdriver
 
 from SeleniumLibrary.base import keyword, LibraryComponent
 from SeleniumLibrary.locators import WindowManager
-from SeleniumLibrary.utils import (is_falsy, is_truthy, is_noney, secs_to_timestr,
-                                   timestr_to_secs, SELENIUM_VERSION)
-
-
-ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-FIREFOX_PROFILE_DIR = os.path.join(ROOT_DIR, 'resources', 'firefoxprofile')
-BROWSER_NAMES = NormalizedDict({
-    'ff': "_make_ff",
-    'firefox': "_make_ff",
-    'ie': "_make_ie",
-    'internetexplorer': "_make_ie",
-    'googlechrome': "_make_chrome",
-    'gc': "_make_chrome",
-    'chrome': "_make_chrome",
-    'opera': "_make_opera",
-    'phantomjs': "_make_phantomjs",
-    'htmlunit': "_make_htmlunit",
-    'htmlunitwithjs': "_make_htmlunitwithjs",
-    'android': "_make_android",
-    'iphone': "_make_iphone",
-    'safari': "_make_safari",
-    'edge': "_make_edge",
-    'headlessfirefox': '_make_headless_ff',
-    'headlesschrome': '_make_headless_chrome'
-})
+from SeleniumLibrary.utils import (is_truthy, is_noney, secs_to_timestr,
+                                   timestr_to_secs)
+
+from .webdrivercreator import WebDriverCreator
 
 
 class BrowserManagementKeywords(LibraryComponent):
@@ -146,8 +123,7 @@ def open_browser(self, url, browser='firefox', alias=None,
                       "remote server at '%s'." % (browser, url, remote_url))
         else:
             self.info("Opening browser '%s' to base url '%s'." % (browser, url))
-        browser_name = browser
-        driver = self._make_driver(browser_name, desired_capabilities,
+        driver = self._make_driver(browser, desired_capabilities,
                                    ff_profile_dir, remote_url)
         try:
             driver.get(url)
@@ -307,8 +283,8 @@ def title_should_be(self, title, message=None):
         """Verifies that current page title equals ``title``.
 
         The ``message`` argument can be used to override the default error
-        message. 
-        
+        message.
+
         ``message`` argument is new in SeleniumLibrary 3.1.
         """
         actual = self.get_title()
@@ -441,145 +417,17 @@ def set_browser_implicit_wait(self, value):
         """
         self.driver.implicitly_wait(timestr_to_secs(value))
 
-    def _get_driver_creation_function(self, browser_name):
-        try:
-            func_name = BROWSER_NAMES[browser_name]
-        except KeyError:
-            raise ValueError(browser_name + " is not a supported browser.")
-        return getattr(self, func_name)
-
-    def _make_driver(self, browser_name, desired_capabilities=None,
+    def _make_driver(self, browser, desired_capabilities=None,
                      profile_dir=None, remote=None):
-        creation_func = self._get_driver_creation_function(browser_name)
-        driver = creation_func(remote, desired_capabilities, profile_dir)
+        driver = WebDriverCreator(self.log_dir).create_driver(
+            browser=browser, desired_capabilities=desired_capabilities,
+            remote_url=remote, profile_dir=profile_dir)
         driver.set_script_timeout(self.ctx.timeout)
         driver.implicitly_wait(self.ctx.implicit_wait)
         if self.ctx.speed:
             self._monkey_patch_speed(driver)
         return driver
 
-    def _make_ff(self, remote, desired_capabilities, profile_dir, options=None):
-        if is_falsy(profile_dir):
-            profile = webdriver.FirefoxProfile()
-        else:
-            profile = webdriver.FirefoxProfile(profile_dir)
-        if is_truthy(remote):
-            driver = self._create_remote_web_driver(
-                webdriver.DesiredCapabilities.FIREFOX, remote,
-                desired_capabilities, profile, options=options)
-        else:
-            driver = webdriver.Firefox(firefox_profile=profile,
-                                       options=options,
-                                       **self._geckodriver_log_config)
-        return driver
-
-    def _make_headless_ff(self, remote, desired_capabilities, profile_dir):
-        options = webdriver.FirefoxOptions()
-        options.set_headless()
-        return self._make_ff(remote, desired_capabilities, profile_dir, options=options)
-
-    def _make_ie(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Ie, webdriver.DesiredCapabilities.INTERNETEXPLORER,
-            remote, desired_capabilities)
-
-    def _make_chrome(self, remote, desired_capabilities, profile_dir, options=None):
-        return self._generic_make_driver(
-            webdriver.Chrome, webdriver.DesiredCapabilities.CHROME, remote,
-            desired_capabilities, options=options)
-
-    def _make_headless_chrome(self, remote, desired_capabilities, profile_dir):
-        options = webdriver.ChromeOptions()
-        options.set_headless()
-        return self._make_chrome(remote, desired_capabilities, profile_dir, options)
-
-    def _make_opera(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Opera, webdriver.DesiredCapabilities.OPERA, remote,
-            desired_capabilities)
-
-    def _make_phantomjs(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.PhantomJS, webdriver.DesiredCapabilities.PHANTOMJS,
-            remote, desired_capabilities)
-
-    def _make_htmlunit(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Remote, webdriver.DesiredCapabilities.HTMLUNIT, remote,
-            desired_capabilities)
-
-    def _make_htmlunitwithjs(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Remote, webdriver.DesiredCapabilities.HTMLUNITWITHJS,
-            remote, desired_capabilities)
-
-    def _make_android(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Remote, webdriver.DesiredCapabilities.ANDROID, remote,
-            desired_capabilities)
-
-    def _make_iphone(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Remote, webdriver.DesiredCapabilities.IPHONE, remote,
-            desired_capabilities)
-
-    def _make_safari(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Safari, webdriver.DesiredCapabilities.SAFARI, remote,
-            desired_capabilities)
-
-    def _make_edge(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_driver(
-            webdriver.Edge, webdriver.DesiredCapabilities.EDGE, remote,
-            desired_capabilities)
-
-    def _generic_make_driver(self, webdriver_type, desired_cap_type,
-                             remote_url, desired_caps, options=None):
-        """Generic driver creation
-
-        Most of the make driver functions just call this function which
-        creates the appropriate driver
-        """
-        if is_falsy(remote_url):
-            if options is None:
-                driver = webdriver_type()
-            else:
-                driver = webdriver_type(options=options)
-        else:
-            driver = self._create_remote_web_driver(desired_cap_type,
-                                                    remote_url, desired_caps,
-                                                    options=options)
-        return driver
-
-    def _create_remote_web_driver(self, capabilities_type, remote_url,
-                                  desired_capabilities=None, profile=None,
-                                  options=None):
-        '''parses the string based desired_capabilities if neccessary and
-        creates the associated remote web driver'''
-
-        desired_capabilities_object = capabilities_type.copy()
-        if not isinstance(desired_capabilities, dict):
-            desired_capabilities = self._parse_capabilities_string(desired_capabilities)
-        desired_capabilities_object.update(desired_capabilities or {})
-        return webdriver.Remote(desired_capabilities=desired_capabilities_object,
-                command_executor=str(remote_url), browser_profile=profile,
-                options=options)
-
-    def _parse_capabilities_string(self, capabilities_string):
-        '''parses the string based desired_capabilities which should be in the form
-        key1:val1,key2:val2
-        '''
-        desired_capabilities = {}
-
-        if is_falsy(capabilities_string):
-            return desired_capabilities
-
-        for cap in capabilities_string.split(","):
-            (key, value) = cap.split(":", 1)
-            desired_capabilities[key.strip()] = value.strip()
-
-        return desired_capabilities
-
     def _monkey_patch_speed(self, driver):
         def execute(self, driver_command, params=None):
             result = self._base_execute(driver_command, params)
@@ -591,9 +439,3 @@ def execute(self, driver_command, params=None):
             driver._base_execute = driver.execute
             driver.execute = types.MethodType(execute, driver)
         driver._speed = self.ctx.speed
-
-    @property
-    def _geckodriver_log_config(self):
-        if SELENIUM_VERSION.major == '3':
-            return {'log_path': os.path.join(self.log_dir, 'geckodriver.log')}
-        return {}

src/SeleniumLibrary/keywords/waiting.py

@@ -18,7 +18,7 @@
 
 from SeleniumLibrary.base import LibraryComponent, keyword
 from SeleniumLibrary.errors import ElementNotFound
-from SeleniumLibrary.utils import is_noney, is_truthy, secs_to_timestr
+from SeleniumLibrary.utils import is_noney, secs_to_timestr
 
 
 class WaitingKeywords(LibraryComponent):