def open_browser(
self,
url,
browser="firefox",
alias=None,
remote_url=False,
desired_capabilities=None,
ff_profile_dir=None,
options=None,
service_log_path=None,
extra_dictionary=None,
executable_path=None,
):
self._new_creator.extra_dictionary = extra_dictionary
browser_manager = BrowserManagementKeywords(self.ctx)
browser_manager._make_driver = self._make_driver
browser_manager.open_browser(
url,
browser=browser,
alias=alias,
remote_url=remote_url,
desired_capabilities=desired_capabilities,
ff_profile_dir=ff_profile_dir,
options=options,
service_log_path=service_log_path,
executable_path=None,
)
class KeywordArgumentsElementTest(unittest.TestCase):
def setUp(self):
ctx = mock()
ctx.event_firing_webdriver = None
ctx._browser = mock()
ctx._drivers = mock()
self.brorser = BrowserManagementKeywords(ctx)
def tearDown(self):
unstub()
def test_open_browser(self):
url = 'https://github.com/robotframework'
remote_url = '"http://localhost:4444/wd/hub"'
browser = mock()
when(self.brorser)._make_driver('firefox', None,
None, False).thenReturn(browser)
alias = self.brorser.open_browser(url)
self.assertEqual(alias, None)
when(self.brorser)._make_driver('firefox', None,
None, remote_url).thenReturn(browser)
alias = self.brorser.open_browser(url, alias='None',
remote_url=remote_url)
self.assertEqual(alias, None)
class KeywordArgumentsElementTest(unittest.TestCase):
def setUp(self):
ctx = mock()
ctx.event_firing_webdriver = None
ctx._browser = mock()
ctx._drivers = mock()
self.brorser = BrowserManagementKeywords(ctx)
def tearDown(self):
unstub()
def test_open_browser(self):
url = 'https://github.com/robotframework'
remote_url = '"http://localhost:4444/wd/hub"'
browser = mock()
when(self.brorser)._make_driver('firefox', None, None,
False).thenReturn(browser)
alias = self.brorser.open_browser(url)
self.assertEqual(alias, None)
when(self.brorser)._make_driver('firefox', None, None,
remote_url).thenReturn(browser)
alias = self.brorser.open_browser(url,
alias='None',
remote_url=remote_url)
self.assertEqual(alias, None)
def create_rpa_webdriver(self,
browser: str,
options: dict,
download: bool = False) -> Any:
"""Create a webdriver instance for the given browser.
The driver will be downloaded if it does not exist when ``download`` is True.
``browser`` name of the browser
``options`` options for webdriver
``download`` if the driver should be download, default ``False``
Returns an index of the webdriver session, ``None`` if webdriver
was not initialized.
"""
self.logger.debug("Driver options for create_rpa_webdriver: %s",
options)
executable = webdriver.executable(browser, download)
try:
browser = browser.lower().capitalize()
browser_management = BrowserManagementKeywords(self)
if executable:
index = browser_management.create_webdriver(
browser, **options, executable_path=executable)
else:
index = browser_management.create_webdriver(browser, **options)
return index
except WebDriverException as err:
self.logger.info("Could not open driver: %s", err)
return None
def setUp(self):
ctx = mock()
ctx.event_firing_webdriver = None
ctx._browser = mock()
ctx._drivers = mock()
self.ctx = ctx
self.brorser = BrowserManagementKeywords(ctx)
def test_bad_browser_name(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
try:
bm._make_driver("fireox")
self.fail("Exception not raised")
except ValueError as e:
self.assertEquals(str(e), "fireox is not a supported browser.")
def test_bad_browser_name():
ctx = mock()
bm = BrowserManagementKeywords(ctx)
try:
bm._make_driver("fireox")
raise ValueError("Exception not raised")
except ValueError as e:
assert str(e) == "fireox is not a supported browser."
def test_bad_browser_name(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
try:
bm._make_driver("fireox")
self.fail("Exception not raised")
except ValueError as e:
self.assertEquals(str(e), "fireox is not a supported browser.")
def test_parse_complex_capabilities_string(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
expected_caps = "proxyType:manual,httpProxy:IP:port"
capabilities = bm._parse_capabilities_string(expected_caps)
self.assertTrue("manual", capabilities["proxyType"])
self.assertTrue("IP:port", capabilities["httpProxy"])
self.assertTrue(2, len(capabilities))
unstub()
def test_create_webdriver_speed(self):
ctx = mock()
ctx.speed = 0.0
browser = mock()
when(webdriver).Chrome().thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
verify(browser, times=0).__call__('_speed')
unstub()
def test_open_browser_speed(self):
ctx = mock()
ctx.speed = 5.0
browser = mock()
when(webdriver).Chrome().thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
self.assertEqual(browser._speed, 5.0)
unstub()
def test_open_browser_speed(self):
ctx = mock()
ctx.speed = 5.0
browser = mock()
when(webdriver).Chrome().thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
self.assertEqual(browser._speed, 5.0)
unstub()
def test_create_webdriver_speed(self):
ctx = mock()
ctx.speed = 0.0
browser = mock()
when(webdriver).Chrome().thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
verify(browser, times=0).__call__('_speed')
unstub()
def test_parse_capabilities_string(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
expected_caps = "key1:val1,key2:val2"
capabilities = bm._parse_capabilities_string(expected_caps)
self.assertTrue("val1", capabilities["key1"])
self.assertTrue("val2", capabilities["key2"])
self.assertTrue(2, len(capabilities))
unstub()
def test_parse_complex_capabilities_string(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
expected_caps = "proxyType:manual,httpProxy:IP:port"
capabilities = bm._parse_capabilities_string(expected_caps)
self.assertTrue("manual", capabilities["proxyType"])
self.assertTrue("IP:port", capabilities["httpProxy"])
self.assertTrue(2, len(capabilities))
unstub()
def test_parse_capabilities_string(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
expected_caps = "key1:val1,key2:val2"
capabilities = bm._parse_capabilities_string(expected_caps)
self.assertTrue("val1", capabilities["key1"])
self.assertTrue("val2", capabilities["key2"])
self.assertTrue(2, len(capabilities))
unstub()
def __init__(self):
ctx = SeleniumLibrary(screenshot_root_directory='Results')
AlertKeywords.__init__(self, ctx)
BrowserManagementKeywords.__init__(self, ctx)
ElementKeywords.__init__(self, ctx)
FormElementKeywords.__init__(self, ctx)
ScreenshotKeywords.__init__(self, ctx)
SelectElementKeywords.__init__(self, ctx)
WaitingKeywords.__init__(self, ctx)
self.screenshot_directory = ctx.screenshot_root_directory
self.builtIn = CRFBuiltIn()
def test_open_browser_speed(self):
ctx = mock()
ctx._drivers = mock()
ctx.event_firing_webdriver = None
ctx.speed = 5.0
browser = mock()
when(webdriver).Chrome(options=None,
service_log_path=None).thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
self.assertEqual(browser._speed, 5.0)
unstub()
def test_create_webdriver_speed(self):
ctx = mock()
ctx._drivers = mock()
ctx.event_firing_webdriver = None
ctx.speed = 0.0
browser = mock()
when(webdriver).Chrome(options=None,
service_log_path=None).thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
verify(browser, times=0).__call__('_speed')
unstub()
class BrowserKeywords(LibraryComponent):
def __init__(self, ctx):
LibraryComponent.__init__(self, ctx)
self.manager = BrowserManagementKeywords(ctx)
@keyword
def open_proxy_browser(self, url=None, browser='chrome', proxy_options=None, alias=None):
index = self.drivers.get_index(alias)
if index:
self.info('Using existing browser from index %s.' % index)
self.manager.switch_browser(alias)
if is_truthy(url):
self.manager.go_to(url)
return index
return self._make_new_browser(url, browser, proxy_options, alias)
@keyword
def create_webdriver(self, driver_name, alias=None, kwargs={}, **init_kwargs):
pass
def _make_new_browser(self, url, browser, proxy_options, alias=None):
driver = self._make_proxy_driver(browser, proxy_options)
driver = self._wrap_event_firing_webdriver(driver)
index = self.ctx.register_driver(driver, alias)
if is_truthy(url):
try:
driver.get(url)
except Exception:
self.debug("Opened browser with session id %s but failed to open url '%s'." % (
driver.session_id, url))
raise
self.debug('Opened browser with session id %s.' % driver.session_id)
return index
def _wrap_event_firing_webdriver(self, driver):
if not self.ctx.event_firing_webdriver:
return driver
self.debug('Wrapping driver to event_firing_webdriver.')
return EventFiringWebDriver(driver, self.ctx.event_firing_webdriver())
def _make_proxy_driver(self, browser, proxy_options):
if browser == 'Chrome':
driver = webdriver.Chrome(options=proxy_options)
elif browser == 'Firefox':
driver = webdriver.Firefox(options=proxy_options)
else:
raise Exception("Browser Type Not Available")
driver.set_script_timeout(self.ctx.timeout)
driver.implicitly_wait(self.ctx.implicit_wait)
return driver
def _create_webdriver(self, browser, alias, download, **kwargs):
"""Create a webdriver instance for the given browser.
Returns an index/alias of the webdriver session,
or ``None`` if a webdriver was not initialized.
"""
executable = webdriver.executable(browser, download)
if executable:
kwargs.setdefault("executable_path", executable)
library = BrowserManagementKeywords(self)
browser = browser.lower().capitalize()
return library.create_webdriver(browser, alias, **kwargs)
def test_create_webdriver_speed(self):
ctx = mock()
ctx.speed = 0.0
browser = mock()
caps = webdriver.DesiredCapabilities.CHROME
if SELENIUM_VERSION.major >= '3' and SELENIUM_VERSION.minor >= '8':
when(webdriver).Chrome(desired_capabilities=caps,
options=None).thenReturn(browser)
else:
when(webdriver).Chrome(
desired_capabilities=caps).thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
verify(browser, times=0).__call__('_speed')
unstub()
def test_open_browser_speed():
ctx = mock()
ctx._drivers = mock()
ctx.event_firing_webdriver = None
ctx.speed = 5.0
browser = mock()
executable_path = "chromedriver"
when(webdriver).Chrome(options=None,
service_log_path=None,
executable_path=executable_path).thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
when(bm._webdriver_creator)._get_executable_path(ANY).thenReturn(
executable_path)
bm.open_browser("http://robotframework.org/", "chrome")
assert browser._speed == 5.0
def test_create_webdriver_speed():
ctx = mock()
ctx._drivers = mock()
ctx.event_firing_webdriver = None
ctx.speed = 0.0
browser = mock()
executable_path = 'chromedriver'
when(webdriver).Chrome(options=None,
service_log_path=None,
executable_path=executable_path).thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
when(bm._webdriver_creator)._get_executable_path(ANY).thenReturn(
executable_path)
bm.open_browser('http://robotframework.org/', 'chrome')
verify(browser, times=0).__call__('_speed')
def test_open_browser_speed(self):
ctx = mock()
ctx.speed = 5.0
browser = mock()
caps = webdriver.DesiredCapabilities.CHROME
if SELENIUM_VERSION.major >= '3' and SELENIUM_VERSION.minor >= '8':
when(webdriver).Chrome(desired_capabilities=caps,
options=None).thenReturn(browser)
else:
when(webdriver).Chrome(
desired_capabilities=caps).thenReturn(browser)
bm = BrowserManagementKeywords(ctx)
bm.open_browser('http://robotframework.org/', 'chrome')
self.assertEqual(browser._speed, 5.0)
unstub()
def verify_browser(self, webdriver_type, browser_name, **kw):
# todo try lambda *x: was_called = true
ctx = mock()
bm = BrowserManagementKeywords(ctx)
old_init = webdriver_type.__init__
webdriver_type.__init__ = self.mock_init
try:
self.was_called = False
bm._make_browser(browser_name, **kw)
except AttributeError:
pass #kinda dangerous but I'm too lazy to mock out all the set_timeout calls
finally:
webdriver_type.__init__ = old_init
self.assertTrue(self.was_called)
unstub()
def __init__(self,
timeout=5.0,
implicit_wait=0.0,
run_on_failure='Capture Page Screenshot',
screenshot_root_directory=None):
self.timeout = timestr_to_secs(timeout)
self.implicit_wait = timestr_to_secs(implicit_wait)
self.speed = 0.0
self.run_on_failure_keyword \
= RunOnFailureKeywords.resolve_keyword(run_on_failure)
self._running_on_failure_keyword = False
self.screenshot_root_directory = screenshot_root_directory
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),
KeyboardKeywords(self)
]
self._drivers = WebDriverCache()
DynamicCore.__init__(self, libraries)
self.ROBOT_LIBRARY_LISTENER = LibraryListener()
self._element_finder = ElementFinder(self)
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):
"""SeleniumLibrary can be imported with several optional arguments.
- ``timeout``:
Default value for `timeouts` used with ``Wait ...`` keywords.
- ``implicit_wait``:
Default value for `implicit wait` used when locating elements.
- ``run_on_failure``:
Default action for the `run-on-failure functionality`.
- ``screenshot_root_directory``:
Location where possible screenshots are created. If not given,
the directory where the log file is written is used.
- ``plugins``:
Allows extending the SeleniumLibrary with external Python classes.
- ``event_firing_webdriver``:
Class for wrapping Selenium with
[https://seleniumhq.github.io/selenium/docs/api/py/webdriver_support/selenium.webdriver.support.event_firing_webdriver.html#module-selenium.webdriver.support.event_firing_webdriver|EventFiringWebDriver]
"""
self.timeout = timestr_to_secs(timeout)
self.implicit_wait = timestr_to_secs(implicit_wait)
self.speed = 0.0
self.run_on_failure_keyword \
= RunOnFailureKeywords.resolve_keyword(run_on_failure)
self._running_on_failure_keyword = False
self.screenshot_root_directory = screenshot_root_directory
self._element_finder = ElementFinder(self)
self._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(plugins)
libraries = libraries + plugin_libs
self._drivers = WebDriverCache()
DynamicCore.__init__(self, libraries)
self.ROBOT_LIBRARY_LISTENER = LibraryListener()
if is_truthy(event_firing_webdriver):
self.event_firing_webdriver = self._parse_listener(
event_firing_webdriver)
else:
self.event_firing_webdriver = None
self._running_keyword = None
def __init__(self,
timeout=5.0,
implicit_wait=0.0,
run_on_failure='Capture Page Screenshot',
screenshot_root_directory=None):
"""SeleniumLibrary can be imported with optional arguments.
`timeout` is the default timeout used to wait for all waiting actions.
It can be later set with `Set Selenium Timeout`.
'implicit_wait' is the implicit timeout that Selenium waits when
looking for elements.
It can be later set with `Set Selenium Implicit Wait`.
See `WebDriver: Advanced Usage`__ section of the SeleniumHQ documentation
for more information about WebDriver's implicit wait functionality.
__ http://seleniumhq.org/docs/04_webdriver_advanced.html#explicit-and-implicit-waits
`run_on_failure` specifies the name of a keyword (from any available
libraries) to execute when a SeleniumLibrary keyword fails. By default
`Capture Page Screenshot` will be used to take a screenshot of the current page.
Using the value "Nothing" will disable this feature altogether. See
`Register Keyword To Run On Failure` keyword for more information about this
functionality.
`screenshot_root_directory` specifies the default root directory that screenshots should be
stored in. If not provided the default directory will be where robotframework places its logfile.
Examples:
| Library `|` SeleniumLibrary `|` 15 | # Sets default timeout to 15 seconds |
| Library `|` SeleniumLibrary `|` 0 `|` 5 | # Sets default timeout to 0 seconds and default implicit_wait to 5 seconds |
| Library `|` SeleniumLibrary `|` 5 `|` run_on_failure=Log Source | # Sets default timeout to 5 seconds and runs `Log Source` on failure |
| Library `|` SeleniumLibrary `|` implicit_wait=5 `|` run_on_failure=Log Source | # Sets default implicit_wait to 5 seconds and runs `Log Source` on failure |
| Library `|` SeleniumLibrary `|` timeout=10 `|` run_on_failure=Nothing | # Sets default timeout to 10 seconds and does nothing on failure |
"""
self.timeout = timestr_to_secs(timeout)
self.implicit_wait = timestr_to_secs(implicit_wait)
self.speed = 0.0
self.run_on_failure_keyword \
= RunOnFailureKeywords.resolve_keyword(run_on_failure)
self._running_on_failure_keyword = False
self.screenshot_root_directory = screenshot_root_directory
libraries = [
AlertKeywords(self),
BrowserManagementKeywords(self),
RunOnFailureKeywords(self),
ElementKeywords(self),
TableElementKeywords(self),
FormElementKeywords(self),
SelectElementKeywords(self),
JavaScriptKeywords(self),
CookieKeywords(self),
ScreenshotKeywords(self),
WaitingKeywords(self)
]
self._browsers = BrowserCache()
DynamicCore.__init__(self, libraries)
self.ROBOT_LIBRARY_LISTENER = LibraryListener()
self.element_finder = ElementFinder(self)
self._table_element_finder = TableElementFinder(self)
def verify_browser(self, webdriver_type, browser_name, **kw):
# todo try lambda *x: was_called = true
ctx = mock()
bm = BrowserManagementKeywords(ctx)
old_init = webdriver_type.__init__
webdriver_type.__init__ = self.mock_init
try:
self.was_called = False
bm._make_browser(browser_name, **kw)
except AttributeError:
pass #kinda dangerous but I'm too lazy to mock out all the set_timeout calls
finally:
webdriver_type.__init__ = old_init
self.assertTrue(self.was_called)
unstub()
def test_set_selenium_timeout_only_affects_open_browsers(self):
ctx = mock()
ctx.timeout = 5.0
_drivers = mock()
ctx._drivers = _drivers
first_browser, second_browser = mock(), mock()
ctx._drivers.active_drivers = [first_browser, second_browser]
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
ctx._drivers.active_drivers = []
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
unstub()
class KeywordArgumentsElementTest(unittest.TestCase):
def setUp(self):
ctx = mock()
ctx.event_firing_webdriver = None
ctx._browser = mock()
ctx._drivers = mock()
self.ctx = ctx
self.brorser = BrowserManagementKeywords(ctx)
def tearDown(self):
unstub()
def test_open_browser(self):
url = "https://github.com/robotframework"
remote_url = '"http://localhost:4444/wd/hub"'
browser = mock()
when(self.brorser)._make_driver(
"firefox", None, None, False, None, None, None
).thenReturn(browser)
alias = self.brorser.open_browser(url)
self.assertEqual(alias, None)
when(self.brorser)._make_driver(
"firefox", None, None, remote_url, None, None, None
).thenReturn(browser)
alias = self.brorser.open_browser(url, alias="None", remote_url=remote_url)
self.assertEqual(alias, None)
def test_same_alias(self):
url = "https://github.com/robotframework"
alias = "tidii"
driver = mock()
driver.session_id = "foobar"
self.ctx.driver = driver
when(self.ctx._drivers).get_index(alias).thenReturn(1)
when(self.ctx._drivers).switch(1).thenReturn(driver)
self.brorser.open_browser(url=url, alias=alias)
verify(driver, times=1).get(url)
def test_open_browser_no_get(self):
browser = mock()
when(self.brorser)._make_driver(
"firefox", None, None, False, None, None, None
).thenReturn(browser)
self.brorser.open_browser()
verify(browser, times=0).get(ANY)
def test_same_alias_and_not_get(self):
alias = "tidii"
driver = mock()
driver.session_id = "foobar"
self.ctx.driver = driver
when(self.ctx._drivers).get_index(alias).thenReturn(1)
when(self.ctx._drivers).switch(1).thenReturn(driver)
self.brorser.open_browser(alias=alias)
verify(driver, times=0).get(ANY)
def test_create_webdriver(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
FakeWebDriver = mock()
driver = mock()
when(FakeWebDriver).__call__(some_arg=1).thenReturn(driver)
when(FakeWebDriver).__call__(some_arg=2).thenReturn(driver)
when(ctx).register_browser(driver, 'fake1').thenReturn(0)
webdriver.FakeWebDriver = FakeWebDriver
try:
index = bm.create_webdriver('FakeWebDriver', 'fake1', some_arg=1)
verify(ctx).register_browser(driver, 'fake1')
self.assertEqual(index, 0)
my_kwargs = {'some_arg': 2}
bm.create_webdriver('FakeWebDriver', 'fake2', kwargs=my_kwargs)
verify(ctx).register_browser(driver, 'fake2')
finally:
del webdriver.FakeWebDriver
unstub()
def test_create_webdriver():
ctx = mock()
ctx.event_firing_webdriver = None
bm = BrowserManagementKeywords(ctx)
FakeWebDriver = mock()
driver = mock()
when(FakeWebDriver).__call__(some_arg=1).thenReturn(driver)
when(FakeWebDriver).__call__(some_arg=2).thenReturn(driver)
when(ctx).register_driver(driver, "fake1").thenReturn(0)
webdriver.FakeWebDriver = FakeWebDriver
try:
index = bm.create_webdriver("FakeWebDriver", "fake1", some_arg=1)
verify(ctx).register_driver(driver, "fake1")
assert index == 0
my_kwargs = {"some_arg": 2}
bm.create_webdriver("FakeWebDriver", "fake2", kwargs=my_kwargs)
verify(ctx).register_driver(driver, "fake2")
finally:
del webdriver.FakeWebDriver
def test_create_webdriver(self):
ctx = mock()
bm = BrowserManagementKeywords(ctx)
FakeWebDriver = mock()
driver = mock()
when(FakeWebDriver).__call__(some_arg=1).thenReturn(driver)
when(FakeWebDriver).__call__(some_arg=2).thenReturn(driver)
when(ctx).register_driver(driver, 'fake1').thenReturn(0)
webdriver.FakeWebDriver = FakeWebDriver
try:
index = bm.create_webdriver('FakeWebDriver', 'fake1', some_arg=1)
verify(ctx).register_driver(driver, 'fake1')
self.assertEqual(index, 0)
my_kwargs = {'some_arg': 2}
bm.create_webdriver('FakeWebDriver', 'fake2', kwargs=my_kwargs)
verify(ctx).register_driver(driver, 'fake2')
finally:
del webdriver.FakeWebDriver
unstub()
def test_set_selenium_timeout_only_affects_open_browsers(self):
ctx = mock()
ctx.timeout = 5.0
_browsers = mock()
ctx._browsers = _browsers
first_browser, second_browser = mock(), mock()
when(_browsers).get_open_browsers().thenReturn(
[first_browser, second_browser]
)
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
when(_browsers).get_open_browsers().thenReturn(
[]
)
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
unstub()
def __init__(self,
timeout=5.0,
implicit_wait=0.0,
run_on_failure='Capture Page Screenshot',
screenshot_root_directory=None,
demo=False):
"""SeleniumLibrary can be imported with several optional arguments.
- ``timeout``:
Default value for `timeouts` used with ``Wait ...`` keywords.
- ``implicit_wait``:
Default value for `implicit wait` used when locating elements.
- ``run_on_failure``:
Default action for the `run-on-failure functionality`.
- ``screenshot_root_directory``:
Location where possible screenshots are created. If not given,
the directory where the log file is written is used.
- ``Demo``
Flash the element before click, input and etc actions. Set value
True if you want it.
"""
self.timeout = timestr_to_secs(timeout)
self.implicit_wait = timestr_to_secs(implicit_wait)
self.speed = 0.0
self.run_on_failure_keyword \
= RunOnFailureKeywords.resolve_keyword(run_on_failure)
self._running_on_failure_keyword = False
self.screenshot_root_directory = screenshot_root_directory
self.demo = demo
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)
]
self._drivers = WebDriverCache()
DynamicCore.__init__(self, libraries)
self.ROBOT_LIBRARY_LISTENER = LibraryListener()
self._element_finder = ElementFinder(self)
def test_set_selenium_timeout_only_affects_open_browsers():
ctx = mock()
ctx.timeout = 5.0
_drivers = mock()
ctx._drivers = _drivers
first_browser, second_browser = mock(), mock()
ctx._drivers.active_drivers = [first_browser, second_browser]
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
ctx._drivers.active_drivers = []
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
def test_set_selenium_timeout_only_affects_open_browsers(self):
ctx = mock()
ctx.timeout = 5.0
_browsers = mock()
ctx._browsers = _browsers
first_browser, second_browser = mock(), mock()
when(_browsers).get_open_browsers().thenReturn(
[first_browser, second_browser])
bm = BrowserManagementKeywords(ctx)
bm.set_selenium_timeout("10 seconds")
verify(first_browser).set_script_timeout(10.0)
verify(second_browser).set_script_timeout(10.0)
when(_browsers).get_open_browsers().thenReturn([])
bm.set_selenium_timeout("20 seconds")
verifyNoMoreInteractions(first_browser)
verifyNoMoreInteractions(second_browser)
unstub()
def setUp(self):
ctx = mock()
ctx._browser = mock()
self.brorser = BrowserManagementKeywords(ctx)
def open_browser(self, host):
logger.info('This is keyword from KeywordClass')
url = 'http://{}:7272/'.format(host)
browser_management = BrowserManagementKeywords(self.ctx)
browser_management.open_browser(url, 'chrome')
def open_browser(self, host):
logger.info('This is keyword from KeywordClass')
url = 'http://{}.com/'.format(host)
browser_management = BrowserManagementKeywords(self.ctx)
browser_management.open_browser(url, 'chrome')
def setUp(self):
ctx = mock()
ctx.event_firing_webdriver = None
ctx._browser = mock()
ctx._drivers = mock()
self.brorser = BrowserManagementKeywords(ctx)
def open_browser(self, host):
url = 'http://{}.com/'.format(host)
browser_management = BrowserManagementKeywords(self.ctx)
browser_management.open_browser(url, 'chrome')
