Skip to content

Commit 31bb16e

Browse files
aaltataaltat
authored
Remote url and caps in open browser (#1281)
When using remote_url the desired_capabilities argument must not be mandatory.
1 parent 92c1210 commit 31bb16e

File tree

2 files changed

+146
-23
lines changed

2 files changed

+146
-23
lines changed

‎src/SeleniumLibrary/keywords/webdrivertools.py‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -87,6 +87,8 @@ def _string_to_dict(self, capabilities):
8787

8888
def create_chrome(self, desired_capabilities, remote_url, options=None):
8989
if is_truthy(remote_url):
90+
if not desired_capabilities:
91+
desired_capabilities = {'desired_capabilities': webdriver.DesiredCapabilities.CHROME.copy()}
9092
return self._remote(desired_capabilities, remote_url, options=options)
9193
if SELENIUM_VERSION.major >= 3 and SELENIUM_VERSION.minor >= 8:
9294
return webdriver.Chrome(options=options, **desired_capabilities)
@@ -104,6 +106,8 @@ def create_firefox(self, desired_capabilities, remote_url, ff_profile_dir,
104106
options=None):
105107
profile = self._get_ff_profile(ff_profile_dir)
106108
if is_truthy(remote_url):
109+
if not desired_capabilities:
110+
desired_capabilities = {'desired_capabilities': webdriver.DesiredCapabilities.FIREFOX.copy()}
107111
return self._remote(desired_capabilities, remote_url,
108112
profile, options)
109113
desired_capabilities.update(self._geckodriver_log)
@@ -136,28 +140,43 @@ def create_headless_firefox(self, desired_capabilities, remote_url,
136140

137141
def create_ie(self, desired_capabilities, remote_url):
138142
if is_truthy(remote_url):
143+
if not desired_capabilities:
144+
ie = webdriver.DesiredCapabilities.INTERNETEXPLORER.copy()
145+
desired_capabilities = {'desired_capabilities': ie}
139146
return self._remote(desired_capabilities, remote_url)
140147
return webdriver.Ie(**desired_capabilities)
141148

142149
def create_edge(self, desired_capabilities, remote_url):
143150
if is_truthy(remote_url):
151+
if not desired_capabilities:
152+
edge = webdriver.DesiredCapabilities.EDGE.copy()
153+
desired_capabilities = {'desired_capabilities': edge}
144154
return self._remote(desired_capabilities, remote_url)
145155
return webdriver.Edge(**desired_capabilities)
146156

147157
def create_opera(self, desired_capabilities, remote_url):
148158
if is_truthy(remote_url):
159+
if not desired_capabilities:
160+
opera = webdriver.DesiredCapabilities.OPERA.copy()
161+
desired_capabilities = {'desired_capabilities': opera}
149162
return self._remote(desired_capabilities, remote_url)
150163
return webdriver.Opera(**desired_capabilities)
151164

152165
def create_safari(self, desired_capabilities, remote_url):
153166
if is_truthy(remote_url):
167+
if not desired_capabilities:
168+
caps = webdriver.DesiredCapabilities.SAFARI.copy()
169+
desired_capabilities = {'desired_capabilities': caps}
154170
return self._remote(desired_capabilities, remote_url)
155171
return webdriver.Safari(**desired_capabilities)
156172

157173
def create_phantomjs(self, desired_capabilities, remote_url):
158174
warnings.warn('SeleniumLibrary support for PhantomJS has been deprecated, '
159175
'please use headlesschrome or headlessfirefox instead.')
160176
if is_truthy(remote_url):
177+
if not desired_capabilities:
178+
caps = webdriver.DesiredCapabilities.PHANTOMJS.copy()
179+
desired_capabilities = {'desired_capabilities': caps}
161180
return self._remote(desired_capabilities, remote_url)
162181
return webdriver.PhantomJS(**desired_capabilities)
163182

‎utest/test/keywords/test_webdrivercreator.py‎

Lines changed: 127 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -91,15 +91,28 @@ def test_chrome_with_desired_capabilities(self):
9191
driver = self.creator.create_chrome({'desired_capabilities': {'key': 'value'}}, None)
9292
self.assertEqual(driver, expected_webdriver)
9393

94-
def test_chrome_remote(self):
94+
def test_chrome_remote_no_caps(self):
9595
url = 'http://localhost:4444/wd/hub'
9696
expected_webdriver = mock()
97+
capabilities = webdriver.DesiredCapabilities.CHROME.copy()
9798
when(webdriver).Remote(command_executor=url,
9899
browser_profile=None,
100+
desired_capabilities=capabilities,
99101
options=None).thenReturn(expected_webdriver)
100102
driver = self.creator.create_chrome({}, url)
101103
self.assertEqual(driver, expected_webdriver)
102104

105+
def test_chrome_remote_caps(self):
106+
url = 'http://localhost:4444/wd/hub'
107+
expected_webdriver = mock()
108+
capabilities = {"browserName": "chrome"}
109+
when(webdriver).Remote(command_executor=url,
110+
browser_profile=None,
111+
desired_capabilities=capabilities,
112+
options=None).thenReturn(expected_webdriver)
113+
driver = self.creator.create_chrome({'desired_capabilities': capabilities}, url)
114+
self.assertEqual(driver, expected_webdriver)
115+
103116
def test_chrome_healdless(self):
104117
expected_webdriver = mock()
105118
options = mock()
@@ -114,8 +127,10 @@ def test_chrome_healdless_with_grid(self):
114127
options = mock()
115128
when(webdriver).ChromeOptions().thenReturn(options)
116129
remote_url = 'localhost:4444'
130+
capabilities = webdriver.DesiredCapabilities.CHROME.copy()
117131
when(webdriver).Remote(command_executor=remote_url,
118-
options=options, browser_profile=None).thenReturn(expected_webdriver)
132+
options=options, browser_profile=None,
133+
desired_capabilities=capabilities).thenReturn(expected_webdriver)
119134
driver = self.creator.create_headless_chrome({}, remote_url)
120135
verify(options).set_headless()
121136
self.assertEqual(driver, expected_webdriver)
@@ -132,17 +147,30 @@ def test_firefox(self):
132147
self.assertEqual(driver, expected_webdriver)
133148
verify(webdriver).FirefoxProfile()
134149

135-
def test_firefox_remote(self):
150+
def test_firefox_remote_no_caps(self):
136151
url = 'http://localhost:4444/wd/hub'
137152
profile = mock()
138153
when(webdriver).FirefoxProfile().thenReturn(profile)
139154
expected_webdriver = mock()
155+
capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()
140156
when(webdriver).Remote(command_executor=url,
141-
browser_profile=profile,
142-
options=None).thenReturn(expected_webdriver)
157+
browser_profile=profile, options=None,
158+
desired_capabilities=capabilities).thenReturn(expected_webdriver)
143159
driver = self.creator.create_firefox({}, url, None)
144160
self.assertEqual(driver, expected_webdriver)
145161

162+
def test_firefox_remote_caps(self):
163+
url = 'http://localhost:4444/wd/hub'
164+
profile = mock()
165+
when(webdriver).FirefoxProfile().thenReturn(profile)
166+
expected_webdriver = mock()
167+
capabilities = {"browserName": "firefox"}
168+
when(webdriver).Remote(command_executor=url,
169+
browser_profile=profile, options=None,
170+
desired_capabilities=capabilities).thenReturn(expected_webdriver)
171+
driver = self.creator.create_firefox({'desired_capabilities': capabilities}, url, None)
172+
self.assertEqual(driver, expected_webdriver)
173+
146174
def test_firefox_profile(self):
147175
expected_webdriver = mock()
148176
profile = mock()
@@ -166,7 +194,7 @@ def test_firefox_headless(self):
166194
driver = self.creator.create_headless_firefox({}, None, None)
167195
self.assertEqual(driver, expected_webdriver)
168196

169-
def test_firefox_healdless_with_grid(self):
197+
def test_firefox_healdless_with_grid_caps(self):
170198
expected_webdriver = mock()
171199
options = mock()
172200
when(webdriver).FirefoxOptions().thenReturn(options)
@@ -179,12 +207,22 @@ def test_firefox_healdless_with_grid(self):
179207
driver = self.creator.create_headless_firefox({'capabilities': {'key': 'value'}}, remote_url, None)
180208
verify(options).set_headless()
181209
self.assertEqual(driver, expected_webdriver)
210+
verify(options).set_headless()
182211

212+
def test_firefox_healdless_with_grid_no_caps(self):
213+
expected_webdriver = mock()
214+
options = mock()
215+
when(webdriver).FirefoxOptions().thenReturn(options)
216+
profile = mock()
217+
when(webdriver).FirefoxProfile().thenReturn(profile)
218+
remote_url = 'localhost:4444'
219+
capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()
183220
when(webdriver).Remote(command_executor=remote_url, options=options,
221+
desired_capabilities=capabilities,
184222
browser_profile=profile, ).thenReturn(expected_webdriver)
185223
driver = self.creator.create_headless_firefox({}, remote_url, None)
186224
self.assertEqual(driver, expected_webdriver)
187-
verify(options, times=2).set_headless()
225+
verify(options).set_headless()
188226

189227
def test_ie(self):
190228
expected_webdriver = mock()
@@ -196,76 +234,132 @@ def test_ie(self):
196234
driver = self.creator.create_ie({'capabilities': {'key': 'value'}}, None)
197235
self.assertEqual(driver, expected_webdriver)
198236

199-
def test_ie_remote(self):
237+
def test_ie_remote_no_caps(self):
200238
url = 'http://localhost:4444/wd/hub'
201239
expected_webdriver = mock()
202-
when(webdriver).Remote(command_executor=url,
203-
browser_profile=None,
240+
capabilities = webdriver.DesiredCapabilities.INTERNETEXPLORER.copy()
241+
when(webdriver).Remote(command_executor=url, browser_profile=None,
242+
desired_capabilities=capabilities,
204243
options=None).thenReturn(expected_webdriver)
205244
driver = self.creator.create_ie({}, url)
206245
self.assertEqual(driver, expected_webdriver)
207246

247+
def test_ie_remote_caps(self):
248+
url = 'http://localhost:4444/wd/hub'
249+
expected_webdriver = mock()
250+
capabilities = {"browserName": "internet explorer"}
251+
when(webdriver).Remote(command_executor=url, browser_profile=None,
252+
desired_capabilities=capabilities,
253+
options=None).thenReturn(expected_webdriver)
254+
driver = self.creator.create_ie({'capabilities': capabilities}, url)
255+
self.assertEqual(driver, expected_webdriver)
256+
208257
def test_edge(self):
209258
expected_webdriver = mock()
210259
when(webdriver).Edge().thenReturn(expected_webdriver)
211260
driver = self.creator.create_edge({}, None)
212261
self.assertEqual(driver, expected_webdriver)
213262

214-
def test_edge_remote(self):
263+
def test_edge_remote_no_caps(self):
215264
url = 'http://localhost:4444/wd/hub'
216265
expected_webdriver = mock()
217-
when(webdriver).Remote(command_executor=url,
218-
browser_profile=None,
266+
capabilities = webdriver.DesiredCapabilities.EDGE.copy()
267+
when(webdriver).Remote(command_executor=url, browser_profile=None,
268+
desired_capabilities=capabilities,
219269
options=None).thenReturn(expected_webdriver)
220270
driver = self.creator.create_edge({}, url)
221271
self.assertEqual(driver, expected_webdriver)
222272

273+
def test_edge_remote_caps(self):
274+
url = 'http://localhost:4444/wd/hub'
275+
expected_webdriver = mock()
276+
capabilities = {"browserName": "MicrosoftEdge"}
277+
when(webdriver).Remote(command_executor=url, browser_profile=None,
278+
desired_capabilities=capabilities,
279+
options=None).thenReturn(expected_webdriver)
280+
driver = self.creator.create_edge({'capabilities': capabilities}, url)
281+
self.assertEqual(driver, expected_webdriver)
282+
283+
223284
def test_opera(self):
224285
expected_webdriver = mock()
225286
when(webdriver).Opera().thenReturn(expected_webdriver)
226287
driver = self.creator.create_opera({}, None)
227288
self.assertEqual(driver, expected_webdriver)
228289

229-
def test_opera_remote(self):
290+
def test_opera_remote_no_caps(self):
230291
url = 'http://localhost:4444/wd/hub'
231292
expected_webdriver = mock()
232-
when(webdriver).Remote(command_executor=url,
233-
browser_profile=None,
293+
capabilities = webdriver.DesiredCapabilities.OPERA.copy()
294+
when(webdriver).Remote(command_executor=url, browser_profile=None,
295+
desired_capabilities=capabilities,
234296
options=None).thenReturn(expected_webdriver)
235297
driver = self.creator.create_opera({}, url)
236298
self.assertEqual(driver, expected_webdriver)
237299

300+
def test_opera_remote_caps(self):
301+
url = 'http://localhost:4444/wd/hub'
302+
expected_webdriver = mock()
303+
capabilities = {"browserName": "opera"}
304+
when(webdriver).Remote(command_executor=url, browser_profile=None,
305+
desired_capabilities=capabilities,
306+
options=None).thenReturn(expected_webdriver)
307+
driver = self.creator.create_opera({'desired_capabilities': capabilities}, url)
308+
self.assertEqual(driver, expected_webdriver)
309+
238310
def test_safari(self):
239311
expected_webdriver = mock()
240312
when(webdriver).Safari().thenReturn(expected_webdriver)
241313
driver = self.creator.create_safari({}, None)
242314
self.assertEqual(driver, expected_webdriver)
243315

244-
def test_safari_remote(self):
316+
def test_safari_remote_no_caps(self):
245317
url = 'http://localhost:4444/wd/hub'
246318
expected_webdriver = mock()
247-
when(webdriver).Remote(command_executor=url,
248-
browser_profile=None,
319+
capabilities = webdriver.DesiredCapabilities.SAFARI.copy()
320+
when(webdriver).Remote(command_executor=url, browser_profile=None,
321+
desired_capabilities=capabilities,
249322
options=None).thenReturn(expected_webdriver)
250323
driver = self.creator.create_safari({}, url)
251324
self.assertEqual(driver, expected_webdriver)
252325

326+
def test_safari_remote_caps(self):
327+
url = 'http://localhost:4444/wd/hub'
328+
expected_webdriver = mock()
329+
capabilities = {"browserName": "safari"}
330+
when(webdriver).Remote(command_executor=url, browser_profile=None,
331+
desired_capabilities=capabilities,
332+
options=None).thenReturn(expected_webdriver)
333+
driver = self.creator.create_safari({'desired_capabilities': capabilities}, url)
334+
self.assertEqual(driver, expected_webdriver)
335+
253336
def test_phantomjs(self):
254337
expected_webdriver = mock()
255338
when(webdriver).PhantomJS().thenReturn(expected_webdriver)
256339
driver = self.creator.create_phantomjs({}, None)
257340
self.assertEqual(driver, expected_webdriver)
258341

259-
def test_phantomjs_remote(self):
342+
def test_phantomjs_remote_no_caps(self):
260343
url = 'http://localhost:4444/wd/hub'
261344
expected_webdriver = mock()
262-
when(webdriver).Remote(command_executor=url,
263-
browser_profile=None,
345+
capabilities = webdriver.DesiredCapabilities.PHANTOMJS.copy()
346+
when(webdriver).Remote(command_executor=url, browser_profile=None,
347+
desired_capabilities=capabilities,
264348
options=None).thenReturn(expected_webdriver)
265349
driver = self.creator.create_phantomjs({}, url)
266350
self.assertEqual(driver, expected_webdriver)
267351

268-
def test_htmlunit(self):
352+
def test_phantomjs_remote_caps(self):
353+
url = 'http://localhost:4444/wd/hub'
354+
expected_webdriver = mock()
355+
capabilities = {"browserName": "phantomjs"}
356+
when(webdriver).Remote(command_executor=url, browser_profile=None,
357+
desired_capabilities=capabilities,
358+
options=None).thenReturn(expected_webdriver)
359+
driver = self.creator.create_phantomjs({'desired_capabilities': capabilities}, url)
360+
self.assertEqual(driver, expected_webdriver)
361+
362+
def test_htmlunit_no_caps(self):
269363
caps = webdriver.DesiredCapabilities.HTMLUNIT
270364
expected_webdriver = mock()
271365
when(webdriver).Remote(command_executor='None',
@@ -275,6 +369,16 @@ def test_htmlunit(self):
275369
driver = self.creator.create_htmlunit({}, None)
276370
self.assertEqual(driver, expected_webdriver)
277371

372+
def test_htmlunit_no_caps(self):
373+
caps = {"browserName": "htmlunit"}
374+
expected_webdriver = mock()
375+
when(webdriver).Remote(command_executor='None',
376+
desired_capabilities=caps,
377+
browser_profile=None,
378+
options=None).thenReturn(expected_webdriver)
379+
driver = self.creator.create_htmlunit({'desired_capabilities': caps}, None)
380+
self.assertEqual(driver, expected_webdriver)
381+
278382
def test_htmlunit_with_js(self):
279383
caps = webdriver.DesiredCapabilities.HTMLUNITWITHJS
280384
expected_webdriver = mock()

0 commit comments

Comments
 (0)