Remote url and caps in open browser

src/SeleniumLibrary/keywords/webdrivertools.py

@@ -87,6 +87,8 @@ def _string_to_dict(self, capabilities):
 
     def create_chrome(self, desired_capabilities, remote_url, options=None):
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                desired_capabilities = {'desired_capabilities': webdriver.DesiredCapabilities.CHROME.copy()}
             return self._remote(desired_capabilities, remote_url, options=options)
         if SELENIUM_VERSION.major >= 3 and SELENIUM_VERSION.minor >= 8:
             return webdriver.Chrome(options=options, **desired_capabilities)
@@ -104,6 +106,8 @@ def create_firefox(self, desired_capabilities, remote_url, ff_profile_dir,
                        options=None):
         profile = self._get_ff_profile(ff_profile_dir)
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                desired_capabilities = {'desired_capabilities': webdriver.DesiredCapabilities.FIREFOX.copy()}
             return self._remote(desired_capabilities, remote_url,
                                 profile, options)
         desired_capabilities.update(self._geckodriver_log)
@@ -136,28 +140,43 @@ def create_headless_firefox(self, desired_capabilities, remote_url,
 
     def create_ie(self, desired_capabilities, remote_url):
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                ie = webdriver.DesiredCapabilities.INTERNETEXPLORER.copy()
+                desired_capabilities = {'desired_capabilities': ie}
             return self._remote(desired_capabilities, remote_url)
         return webdriver.Ie(**desired_capabilities)
 
     def create_edge(self, desired_capabilities, remote_url):
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                edge = webdriver.DesiredCapabilities.EDGE.copy()
+                desired_capabilities = {'desired_capabilities': edge}
             return self._remote(desired_capabilities, remote_url)
         return webdriver.Edge(**desired_capabilities)
 
     def create_opera(self, desired_capabilities, remote_url):
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                opera = webdriver.DesiredCapabilities.OPERA.copy()
+                desired_capabilities = {'desired_capabilities': opera}
             return self._remote(desired_capabilities, remote_url)
         return webdriver.Opera(**desired_capabilities)
 
     def create_safari(self, desired_capabilities, remote_url):
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                caps = webdriver.DesiredCapabilities.SAFARI.copy()
+                desired_capabilities = {'desired_capabilities': caps}
             return self._remote(desired_capabilities, remote_url)
         return webdriver.Safari(**desired_capabilities)
 
     def create_phantomjs(self, desired_capabilities, remote_url):
         warnings.warn('SeleniumLibrary support for PhantomJS has been deprecated, '
                       'please use headlesschrome or headlessfirefox instead.')
         if is_truthy(remote_url):
+            if not desired_capabilities:
+                caps = webdriver.DesiredCapabilities.PHANTOMJS.copy()
+                desired_capabilities = {'desired_capabilities': caps}
             return self._remote(desired_capabilities, remote_url)
         return webdriver.PhantomJS(**desired_capabilities)
 

utest/test/keywords/test_webdrivercreator.py

@@ -91,15 +91,28 @@ def test_chrome_with_desired_capabilities(self):
         driver = self.creator.create_chrome({'desired_capabilities': {'key': 'value'}}, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_chrome_remote(self):
+    def test_chrome_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         expected_webdriver = mock()
+        capabilities = webdriver.DesiredCapabilities.CHROME.copy()
         when(webdriver).Remote(command_executor=url,
                                browser_profile=None,
+                               desired_capabilities=capabilities,
                                options=None).thenReturn(expected_webdriver)
         driver = self.creator.create_chrome({}, url)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_chrome_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        expected_webdriver = mock()
+        capabilities = {"browserName": "chrome"}
+        when(webdriver).Remote(command_executor=url,
+                               browser_profile=None,
+                               desired_capabilities=capabilities,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_chrome({'desired_capabilities': capabilities}, url)
+        self.assertEqual(driver, expected_webdriver)
+
     def test_chrome_healdless(self):
         expected_webdriver = mock()
         options = mock()
@@ -114,8 +127,10 @@ def test_chrome_healdless_with_grid(self):
         options = mock()
         when(webdriver).ChromeOptions().thenReturn(options)
         remote_url = 'localhost:4444'
+        capabilities = webdriver.DesiredCapabilities.CHROME.copy()
         when(webdriver).Remote(command_executor=remote_url,
-                               options=options, browser_profile=None).thenReturn(expected_webdriver)
+                               options=options, browser_profile=None,
+                               desired_capabilities=capabilities).thenReturn(expected_webdriver)
         driver = self.creator.create_headless_chrome({}, remote_url)
         verify(options).set_headless()
         self.assertEqual(driver, expected_webdriver)
@@ -132,17 +147,30 @@ def test_firefox(self):
         self.assertEqual(driver, expected_webdriver)
         verify(webdriver).FirefoxProfile()
 
-    def test_firefox_remote(self):
+    def test_firefox_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         profile = mock()
         when(webdriver).FirefoxProfile().thenReturn(profile)
         expected_webdriver = mock()
+        capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()
         when(webdriver).Remote(command_executor=url,
-                               browser_profile=profile,
-                               options=None).thenReturn(expected_webdriver)
+                               browser_profile=profile, options=None,
+                               desired_capabilities=capabilities).thenReturn(expected_webdriver)
         driver = self.creator.create_firefox({}, url, None)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_firefox_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        profile = mock()
+        when(webdriver).FirefoxProfile().thenReturn(profile)
+        expected_webdriver = mock()
+        capabilities = {"browserName": "firefox"}
+        when(webdriver).Remote(command_executor=url,
+                               browser_profile=profile, options=None,
+                               desired_capabilities=capabilities).thenReturn(expected_webdriver)
+        driver = self.creator.create_firefox({'desired_capabilities': capabilities}, url, None)
+        self.assertEqual(driver, expected_webdriver)
+
     def test_firefox_profile(self):
         expected_webdriver = mock()
         profile = mock()
@@ -166,7 +194,7 @@ def test_firefox_headless(self):
         driver = self.creator.create_headless_firefox({}, None, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_firefox_healdless_with_grid(self):
+    def test_firefox_healdless_with_grid_caps(self):
         expected_webdriver = mock()
         options = mock()
         when(webdriver).FirefoxOptions().thenReturn(options)
@@ -179,12 +207,22 @@ def test_firefox_healdless_with_grid(self):
         driver = self.creator.create_headless_firefox({'capabilities': {'key': 'value'}}, remote_url, None)
         verify(options).set_headless()
         self.assertEqual(driver, expected_webdriver)
+        verify(options).set_headless()
 
+    def test_firefox_healdless_with_grid_no_caps(self):
+        expected_webdriver = mock()
+        options = mock()
+        when(webdriver).FirefoxOptions().thenReturn(options)
+        profile = mock()
+        when(webdriver).FirefoxProfile().thenReturn(profile)
+        remote_url = 'localhost:4444'
+        capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()
         when(webdriver).Remote(command_executor=remote_url, options=options,
+                               desired_capabilities=capabilities,
                                browser_profile=profile, ).thenReturn(expected_webdriver)
         driver = self.creator.create_headless_firefox({}, remote_url, None)
         self.assertEqual(driver, expected_webdriver)
-        verify(options, times=2).set_headless()
+        verify(options).set_headless()
 
     def test_ie(self):
         expected_webdriver = mock()
@@ -196,76 +234,132 @@ def test_ie(self):
         driver = self.creator.create_ie({'capabilities': {'key': 'value'}}, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_ie_remote(self):
+    def test_ie_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         expected_webdriver = mock()
-        when(webdriver).Remote(command_executor=url,
-                               browser_profile=None,
+        capabilities = webdriver.DesiredCapabilities.INTERNETEXPLORER.copy()
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
                                options=None).thenReturn(expected_webdriver)
         driver = self.creator.create_ie({}, url)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_ie_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        expected_webdriver = mock()
+        capabilities = {"browserName": "internet explorer"}
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_ie({'capabilities': capabilities}, url)
+        self.assertEqual(driver, expected_webdriver)
+
     def test_edge(self):
         expected_webdriver = mock()
         when(webdriver).Edge().thenReturn(expected_webdriver)
         driver = self.creator.create_edge({}, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_edge_remote(self):
+    def test_edge_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         expected_webdriver = mock()
-        when(webdriver).Remote(command_executor=url,
-                               browser_profile=None,
+        capabilities = webdriver.DesiredCapabilities.EDGE.copy()
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
                                options=None).thenReturn(expected_webdriver)
         driver = self.creator.create_edge({}, url)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_edge_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        expected_webdriver = mock()
+        capabilities = {"browserName": "MicrosoftEdge"}
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_edge({'capabilities': capabilities}, url)
+        self.assertEqual(driver, expected_webdriver)
+
+
     def test_opera(self):
         expected_webdriver = mock()
         when(webdriver).Opera().thenReturn(expected_webdriver)
         driver = self.creator.create_opera({}, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_opera_remote(self):
+    def test_opera_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         expected_webdriver = mock()
-        when(webdriver).Remote(command_executor=url,
-                               browser_profile=None,
+        capabilities = webdriver.DesiredCapabilities.OPERA.copy()
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
                                options=None).thenReturn(expected_webdriver)
         driver = self.creator.create_opera({}, url)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_opera_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        expected_webdriver = mock()
+        capabilities = {"browserName": "opera"}
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_opera({'desired_capabilities': capabilities}, url)
+        self.assertEqual(driver, expected_webdriver)
+
     def test_safari(self):
         expected_webdriver = mock()
         when(webdriver).Safari().thenReturn(expected_webdriver)
         driver = self.creator.create_safari({}, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_safari_remote(self):
+    def test_safari_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         expected_webdriver = mock()
-        when(webdriver).Remote(command_executor=url,
-                               browser_profile=None,
+        capabilities = webdriver.DesiredCapabilities.SAFARI.copy()
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
                                options=None).thenReturn(expected_webdriver)
         driver = self.creator.create_safari({}, url)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_safari_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        expected_webdriver = mock()
+        capabilities = {"browserName": "safari"}
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_safari({'desired_capabilities': capabilities}, url)
+        self.assertEqual(driver, expected_webdriver)
+
     def test_phantomjs(self):
         expected_webdriver = mock()
         when(webdriver).PhantomJS().thenReturn(expected_webdriver)
         driver = self.creator.create_phantomjs({}, None)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_phantomjs_remote(self):
+    def test_phantomjs_remote_no_caps(self):
         url = 'http://localhost:4444/wd/hub'
         expected_webdriver = mock()
-        when(webdriver).Remote(command_executor=url,
-                               browser_profile=None,
+        capabilities = webdriver.DesiredCapabilities.PHANTOMJS.copy()
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
                                options=None).thenReturn(expected_webdriver)
         driver = self.creator.create_phantomjs({}, url)
         self.assertEqual(driver, expected_webdriver)
 
-    def test_htmlunit(self):
+    def test_phantomjs_remote_caps(self):
+        url = 'http://localhost:4444/wd/hub'
+        expected_webdriver = mock()
+        capabilities = {"browserName": "phantomjs"}
+        when(webdriver).Remote(command_executor=url, browser_profile=None,
+                               desired_capabilities=capabilities,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_phantomjs({'desired_capabilities': capabilities}, url)
+        self.assertEqual(driver, expected_webdriver)
+
+    def test_htmlunit_no_caps(self):
         caps = webdriver.DesiredCapabilities.HTMLUNIT
         expected_webdriver = mock()
         when(webdriver).Remote(command_executor='None',
@@ -275,6 +369,16 @@ def test_htmlunit(self):
         driver = self.creator.create_htmlunit({}, None)
         self.assertEqual(driver, expected_webdriver)
 
+    def test_htmlunit_no_caps(self):
+        caps = {"browserName": "htmlunit"}
+        expected_webdriver = mock()
+        when(webdriver).Remote(command_executor='None',
+                               desired_capabilities=caps,
+                               browser_profile=None,
+                               options=None).thenReturn(expected_webdriver)
+        driver = self.creator.create_htmlunit({'desired_capabilities': caps}, None)
+        self.assertEqual(driver, expected_webdriver)
+
     def test_htmlunit_with_js(self):
         caps = webdriver.DesiredCapabilities.HTMLUNITWITHJS
         expected_webdriver = mock()