def __init__(
self: "SeleniumTestability",
ctx: SeleniumLibrary,
automatic_wait: bool = True,
timeout: str = "30 seconds",
error_on_timeout: bool = True,
automatic_injection: bool = True,
) -> None:
LibraryComponent.__init__(self, ctx)
self.logger = get_logger("SeleniumTestability")
self.logger.debug("__init__({},{},{},{},{})".format(ctx, automatic_wait, timeout, error_on_timeout, automatic_injection))
self.el = ElementKeywords(ctx)
self.CWD = abspath(dirname(__file__))
self.js_bundle = join(self.CWD, "js", "testability.js")
self.ctx.event_firing_webdriver = TestabilityListener
self.ctx.testability_settings = {"testability": self}
self.automatic_wait = is_truthy(automatic_wait)
self.automatic_injection = is_truthy(automatic_injection)
self.error_on_timeout = is_truthy(error_on_timeout)
self.timeout = timeout # type: ignore
self.hidden_elements = {} # type: Dict[str, str]
self.browser_warn_shown = False
self.empty_log_warn_shown = False
self.ff_log_pos = {} # type: Dict[str, int]
self.testability_config = None # type: OptionalDictType
def __init__(self, ctx):
LibraryComponent.__init__(self, ctx)
self.element = ElementKeywords(ctx)
class WaitingKeywords(LibraryComponent):
def __init__(self, ctx):
LibraryComponent.__init__(self, ctx)
self.element = ElementKeywords(ctx)
@keyword
def wait_for_condition(self, condition, timeout=None, error=None):
"""Waits until the given ``condition`` is true or ``timeout`` expires.
The ``condition`` can be arbitrary JavaScript expression but it
must return a value to be evaluated. See `Execute JavaScript` for
information about accessing content on pages.
``error`` can be used to override the default error message.
See `timeouts` for more information about using timeouts and their
default value.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait Until Element Is Visible` and BuiltIn keyword
`Wait Until Keyword Succeeds`.
"""
if 'return' not in condition:
raise ValueError("Condition '%s' did not have mandatory 'return'."
% condition)
if is_falsy(error):
error = "Condition '%s' did not become true in <TIMEOUT>" % condition
self._wait_until(
timeout, error,
lambda: self.browser.execute_script(condition) is True)
@keyword
def wait_until_page_contains(self, text, timeout=None, error=None):
"""Waits until `text` appears on current page.
Fails if `timeout` expires before the text appears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains Element`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
if is_falsy(error):
error = "Text '%s' did not appear in <TIMEOUT>" % text
self._wait_until(timeout, error, self.element.is_text_present, text)
@keyword
def wait_until_page_does_not_contain(self, text, timeout=None, error=None):
"""Waits until `text` disappears from current page.
Fails if `timeout` expires before the `text` disappears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
def check_present():
present = self.element.is_text_present(text)
if not present:
return
else:
return error or "Text '%s' did not disappear in %s" % (text, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_present)
@keyword
def wait_until_page_contains_element(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` appears on current page.
Fails if `timeout` expires before the element appears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
def is_element_present(locator):
return self.find_element(locator, required=False) is not None
if is_falsy(error):
error = "Element '%s' did not appear in <TIMEOUT>" % locator
self._wait_until(timeout, error, is_element_present, locator)
@keyword
def wait_until_page_does_not_contain_element(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` disappears from current page.
Fails if `timeout` expires before the element disappears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
def check_present():
present = self.find_element(locator, required=False)
if not present:
return
else:
return error or "Element '%s' did not disappear in %s" % (locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_present)
@keyword
def wait_until_element_is_visible(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` is visible.
Fails if `timeout` expires before the element is visible. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait For Condition` and BuiltIn keyword `Wait Until Keyword
Succeeds`.
"""
def check_visibility():
visible = self.element.is_visible(locator)
if visible:
return
elif visible is None:
return error or "Element locator '%s' did not match any elements after %s" % (locator, self._format_timeout(timeout))
else:
return error or "Element '%s' was not visible in %s" % (locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_visibility)
@keyword
def wait_until_element_is_not_visible(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` is not visible.
Fails if `timeout` expires before the element is not visible. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait For Condition` and BuiltIn keyword `Wait Until Keyword
Succeeds`.
"""
def check_hidden():
visible = self.element.is_visible(locator)
if not visible:
return
elif visible is None:
return error or "Element locator '%s' did not match any elements after %s" % (locator, self._format_timeout(timeout))
else:
return error or "Element '%s' was still visible in %s" % (locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_hidden)
@keyword
def wait_until_element_is_enabled(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` is enabled.
Fails if `timeout` expires before the element is enabled. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait For Condition` and BuiltIn keyword `Wait Until Keyword
Succeeds`.
"""
def check_enabled():
element = self.find_element(locator, required=False)
if not element:
return error or "Element locator '%s' did not match any elements after %s" % (locator, self._format_timeout(timeout))
enabled = not element.get_attribute("disabled")
if enabled:
return
else:
return error or "Element '%s' was not enabled in %s" % (locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_enabled)
@keyword
def wait_until_element_contains(self, locator, text, timeout=None, error=None):
"""Waits until given element contains `text`.
Fails if `timeout` expires before the text appears on given element. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains Element`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
element = self.find_element(locator)
def check_text():
actual = element.text
if text in actual:
return
else:
return error or "Text '%s' did not appear in %s to element '%s'. " \
"Its text was '%s'." % (text, self._format_timeout(timeout), locator, actual)
self._wait_until_no_error(timeout, check_text)
@keyword
def wait_until_element_does_not_contain(self, locator, text, timeout=None, error=None):
"""Waits until given element does not contain `text`.
Fails if `timeout` expires before the text disappears from given element. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains Element`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
element = self.find_element(locator)
def check_text():
actual = element.text
if text not in actual:
return
else:
return error or "Text '%s' did not disappear in %s from element '%s'." % (text, self._format_timeout(timeout), locator)
self._wait_until_no_error(timeout, check_text)
def _wait_until(self, timeout, error, function, *args):
error = error.replace('<TIMEOUT>', self._format_timeout(timeout))
def wait_func():
return None if function(*args) else error
self._wait_until_no_error(timeout, wait_func)
def _wait_until_no_error(self, timeout, wait_func, *args):
maxtime = time.time() + self.get_timeout(timeout)
while True:
timeout_error = wait_func(*args)
if not timeout_error:
return
if time.time() > maxtime:
raise AssertionError(timeout_error)
time.sleep(0.2)
def _format_timeout(self, timeout):
return secs_to_timestr(self.get_timeout(timeout))
def __init__(self, ctx):
LibraryComponent.__init__(self, ctx)
self.element = ElementKeywords(ctx)
class WaitingKeywords(LibraryComponent):
def __init__(self, ctx):
LibraryComponent.__init__(self, ctx)
self.element = ElementKeywords(ctx)
@keyword
def wait_for_condition(self, condition, timeout=None, error=None):
"""Waits until the given ``condition`` is true or ``timeout`` expires.
The ``condition`` can be arbitrary JavaScript expression but it
must return a value to be evaluated. See `Execute JavaScript` for
information about accessing content on pages.
``error`` can be used to override the default error message.
See `timeouts` for more information about using timeouts and their
default value.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait Until Element Is Visible` and BuiltIn keyword
`Wait Until Keyword Succeeds`.
"""
if 'return' not in condition:
raise ValueError(
"Condition '%s' did not have mandatory 'return'." % condition)
if is_falsy(error):
error = "Condition '%s' did not become true in <TIMEOUT>" % condition
self._wait_until(
timeout, error,
lambda: self.browser.execute_script(condition) is True)
@keyword
def wait_until_page_contains(self, text, timeout=None, error=None):
"""Waits until `text` appears on current page.
Fails if `timeout` expires before the text appears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains Element`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
if is_falsy(error):
error = "Text '%s' did not appear in <TIMEOUT>" % text
self._wait_until(timeout, error, self.element.is_text_present, text)
@keyword
def wait_until_page_does_not_contain(self, text, timeout=None, error=None):
"""Waits until `text` disappears from current page.
Fails if `timeout` expires before the `text` disappears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
def check_present():
present = self.element.is_text_present(text)
if not present:
return
else:
return error or "Text '%s' did not disappear in %s" % (
text, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_present)
@keyword
def wait_until_page_contains_element(self,
locator,
timeout=None,
error=None):
"""Waits until element specified with `locator` appears on current page.
Fails if `timeout` expires before the element appears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
def is_element_present(locator):
return self.find_element(locator, required=False) is not None
if is_falsy(error):
error = "Element '%s' did not appear in <TIMEOUT>" % locator
self._wait_until(timeout, error, is_element_present, locator)
@keyword
def wait_until_page_does_not_contain_element(self,
locator,
timeout=None,
error=None):
"""Waits until element specified with `locator` disappears from current page.
Fails if `timeout` expires before the element disappears. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
def check_present():
present = self.find_element(locator, required=False)
if not present:
return
else:
return error or "Element '%s' did not disappear in %s" % (
locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_present)
@keyword
def wait_until_element_is_visible(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` is visible.
Fails if `timeout` expires before the element is visible. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait For Condition` and BuiltIn keyword `Wait Until Keyword
Succeeds`.
"""
def check_visibility():
visible = self.element.is_visible(locator)
if visible:
return
elif visible is None:
return error or "Element locator '%s' did not match any elements after %s" % (
locator, self._format_timeout(timeout))
else:
return error or "Element '%s' was not visible in %s" % (
locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_visibility)
@keyword
def wait_until_element_is_not_visible(self,
locator,
timeout=None,
error=None):
"""Waits until element specified with `locator` is not visible.
Fails if `timeout` expires before the element is not visible. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait For Condition` and BuiltIn keyword `Wait Until Keyword
Succeeds`.
"""
def check_hidden():
visible = self.element.is_visible(locator)
if not visible:
return
elif visible is None:
return error or "Element locator '%s' did not match any elements after %s" % (
locator, self._format_timeout(timeout))
else:
return error or "Element '%s' was still visible in %s" % (
locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_hidden)
@keyword
def wait_until_element_is_enabled(self, locator, timeout=None, error=None):
"""Waits until element specified with `locator` is enabled.
Fails if `timeout` expires before the element is enabled. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains
Element`, `Wait For Condition` and BuiltIn keyword `Wait Until Keyword
Succeeds`.
"""
def check_enabled():
element = self.find_element(locator, required=False)
if not element:
return error or "Element locator '%s' did not match any elements after %s" % (
locator, self._format_timeout(timeout))
enabled = not element.get_attribute("disabled")
if enabled:
return
else:
return error or "Element '%s' was not enabled in %s" % (
locator, self._format_timeout(timeout))
self._wait_until_no_error(timeout, check_enabled)
@keyword
def wait_until_element_contains(self,
locator,
text,
timeout=None,
error=None):
"""Waits until given element contains `text`.
Fails if `timeout` expires before the text appears on given element. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains Element`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
element = self.find_element(locator)
def check_text():
actual = element.text
if text in actual:
return
else:
return error or "Text '%s' did not appear in %s to element '%s'. " \
"Its text was '%s'." % (text, self._format_timeout(timeout), locator, actual)
self._wait_until_no_error(timeout, check_text)
@keyword
def wait_until_element_does_not_contain(self,
locator,
text,
timeout=None,
error=None):
"""Waits until given element does not contain `text`.
Fails if `timeout` expires before the text disappears from given element. See
`introduction` for more information about `timeout` and its
default value.
`error` can be used to override the default error message.
See also `Wait Until Page Contains`, `Wait Until Page Contains Element`, `Wait For Condition`,
`Wait Until Element Is Visible` and BuiltIn keyword `Wait Until
Keyword Succeeds`.
"""
element = self.find_element(locator)
def check_text():
actual = element.text
if text not in actual:
return
else:
return error or "Text '%s' did not disappear in %s from element '%s'." % (
text, self._format_timeout(timeout), locator)
self._wait_until_no_error(timeout, check_text)
def _wait_until(self, timeout, error, function, *args):
error = error.replace('<TIMEOUT>', self._format_timeout(timeout))
def wait_func():
return None if function(*args) else error
self._wait_until_no_error(timeout, wait_func)
def _wait_until_no_error(self, timeout, wait_func, *args):
maxtime = time.time() + self.get_timeout(timeout)
while True:
timeout_error = wait_func(*args)
if not timeout_error:
return
if time.time() > maxtime:
raise AssertionError(timeout_error)
time.sleep(0.2)
def _format_timeout(self, timeout):
return secs_to_timestr(self.get_timeout(timeout))
class SeleniumTestability(LibraryComponent):
"""
SeleniumTestability is plugin for SeleniumLibrary that provides either manual or automatic waiting asyncronous events within SUT. This works by injecting small javascript snippets that can monitor the web application's state and when any supported events are happening within the sut, execution of SeleniumLibrary's keywords are blocked until timeout or those events are processed.
On top of this, there are some more or less useful utilities for web application testing.
== Usage ==
Example:
| ***** Settings *****
| Library SeleniumLibrary plugins=SeleniumTestability;True;30 Seconds;True
|
| Suite Setup Open Browser https://127.0.0.1:5000/ browser=Firefox
| Suite Teardown Close Browser
|
| ***** Test Cases *****
| Instrument Browser Example
| ${x}= `Testability Loaded`
| Should Be True ${x}
== Parameters ==
Plugin can take parameters when it is initialized. All of these values can be modified at runtim too with corresponding keywords. Here's a list of the parameters:
=== automatic_wait ===
a truthy value, if SeleniumTestabily should automatically wait for sut to be in state that it can accept more actions.
Can be enabled/disable at runtime.
Defaults to True
=== timeout ===
Robot timestring, amount of time to wait for SUT to be in state that it can be safely interacted with.
Can be set at runtime.
Defaults to 30 seconds.
=== error_on_timeout ===
A truthy value, if timeout does occur either in manual or automatic mode, this determines if error should be thrown that marks marks the exection as failure.
Can be enabled/disabled at runtime.
Defaults to True
=== automatic_injection ===
A truthy value. User can choose if he wants to instrument the SUT manually with appropriate keywords (or even, if the SUT is instrumented at build time?) or should SeleniumTestability determinine if SUT has testability features and if not then inject & instrument it automatically.
Can be enabled/disabled at runtime.
Defaults to True
== Waiting ==
There are two modes of waiting, automatic and non-automatic. When automatic waiting is enabled, when SeleniumLibrary keywords are used, plugin waits until all currently running and supported asyncronous events are done before commencing to use the locator.
=== Automatic ===
| ***** Settings *****
| Library SeleniumLibrary plugins=SeleniumTestability;True;30 Seconds;True
|
| Suite Setup Open Browser https://127.0.0.1:5000/ browser=Firefox
| Suite Teardown Close Browser
|
| ***** Test Cases *****
| Basic Example
| Click Element id:fetch-button
| Click Element id:xhr-button
| `Wait For Testability Ready`
In this scenario, test is clicking first element, waits for the fetch call to finish before clicking on the next. Also, do note that in this example, we are calling `Wait For Testability Ready` to also wait for xhr request to finish as there is no other SeleniumLibrary calls after the second click.
=== Non Automatic ===
| ***** Settings *****
| Library SeleniumLibrary plugins=SeleniumTestability;False;30 Seconds;True
|
| Suite Setup Open Browser https://127.0.0.1:5000/ browser=Firefox
| Suite Teardown Close Browser
|
| ***** Test Cases *****
| Basic Example
| Click Element id:fetch-button
| `Wait For Testability Ready`
| Click Element id:xhr-button
| `Wait For Testability Ready`
= Currently supported Asyncronouse features =
- setTimeout & setImmediate calls and wait for them.
- fetch() call and wait for it to finish
- XHR requests and wait for them to finish
- CSS Animations and wait form them to finish
- CSS Transitions and wait form them to finish
- Viewport scrolling.
*Do note* that catching css animations and transitions is browser dependant. In the past
certain browsers did not implement these features as "the standard" would require.
= Other functionality. =
SeleniumTestability also provides other conveniance keywords that do not make sense to incorporate into
SeleniumLibrary itself, mainly due to functionality not being in scope of SeleniumLibrary and Selenium
python bindings. Do check the keyword documentation for up to date list of keywords.
"""
BROWSERS = {
"googlechrome": DesiredCapabilities.CHROME,
"gc": DesiredCapabilities.CHROME,
"chrome": DesiredCapabilities.CHROME,
"headlesschrome": DesiredCapabilities.CHROME,
"ff": DesiredCapabilities.FIREFOX,
"firefox": DesiredCapabilities.FIREFOX,
"headlessfirefox": DesiredCapabilities.FIREFOX,
"ie": DesiredCapabilities.INTERNETEXPLORER,
"internetexplorer": DesiredCapabilities.INTERNETEXPLORER,
"edge": DesiredCapabilities.EDGE,
"opera": DesiredCapabilities.OPERA,
"safari": DesiredCapabilities.SAFARI,
"htmlunit": DesiredCapabilities.HTMLUNIT,
"htmlunitwithjs": DesiredCapabilities.HTMLUNITWITHJS,
"iphone": DesiredCapabilities.IPHONE,
}
@property
def automatic_wait(self: "SeleniumTestability") -> bool:
return self.ctx.testability_settings["automatic_wait"]
@automatic_wait.setter
def automatic_wait(self: "SeleniumTestability", value: bool) -> None:
self.ctx.testability_settings["automatic_wait"] = value
@property
def error_on_timeout(self: "SeleniumTestability") -> bool:
return self.ctx.testability_settings["error_on_timeout"]
@error_on_timeout.setter
def error_on_timeout(self: "SeleniumTestability", value: bool) -> None:
self.ctx.testability_settings["error_on_timeout"] = value
@property
def timeout(self: "SeleniumTestability") -> float:
return self.ctx.testability_settings["timeout"]
@timeout.setter
def timeout(self: "SeleniumTestability", value: str) -> None:
self.ctx.testability_settings["timeout"] = timestr_to_secs(value)
@property
def automatic_injection(self: "SeleniumTestability") -> bool:
return self.ctx.testability_settings["automatic_injection"]
@automatic_injection.setter
def automatic_injection(self: "SeleniumTestability", value: bool) -> None:
self.ctx.testability_settings["automatic_injection"] = value
def __init__(
self: "SeleniumTestability",
ctx: SeleniumLibrary,
automatic_wait: bool = True,
timeout: str = "30 seconds",
error_on_timeout: bool = True,
automatic_injection: bool = True,
) -> None:
LibraryComponent.__init__(self, ctx)
self.logger = get_logger("SeleniumTestability")
self.logger.debug("__init__({},{},{},{},{})".format(ctx, automatic_wait, timeout, error_on_timeout, automatic_injection))
self.el = ElementKeywords(ctx)
self.CWD = abspath(dirname(__file__))
self.js_bundle = join(self.CWD, "js", "testability.js")
self.ctx.event_firing_webdriver = TestabilityListener
self.ctx.testability_settings = {"testability": self}
self.automatic_wait = is_truthy(automatic_wait)
self.automatic_injection = is_truthy(automatic_injection)
self.error_on_timeout = is_truthy(error_on_timeout)
self.timeout = timeout # type: ignore
self.hidden_elements = {} # type: Dict[str, str]
self.browser_warn_shown = False
self.empty_log_warn_shown = False
self.ff_log_pos = {} # type: Dict[str, int]
self.testability_config = None # type: OptionalDictType
@log_wrapper
def _inject_testability(self: "SeleniumTestability") -> None:
"""
Injects SeleniumTestability javascript bindings into a current browser's current window. This should happen automatically vie SeleniumTestability's internal `Event Firing Webdriver` support but keyword is provided also.
"""
if self.testability_config:
self.ctx.driver.execute_script(JS_LOOKUP["testability_config"], self.testability_config)
with open(self.js_bundle, "r") as f:
buf = f.read()
self.ctx.driver.execute_script("{};".format(buf))
@log_wrapper
@keyword
def set_testability_config(self: "SeleniumTestability", config: Dict) -> None:
"""
Sets configuration that is used by SUT. `config` dictionary should can have following keys: `maxTimeout` and `blacklist`.
Configuration has to be set before opening any browsers or before SUT is instrumented either automatically or manually.
- `maxTimeout` affects affects javascript `setTimeout()` calls and what is the maximum timeout that should be observed and waited. Value is milliseconds and defaults to 5000
- `blacklist` is array of dictionaries where each array element have 2 fields. `url` and `method`. `url` should be a regular expression that matches the actual url or url of the Request object's url field.
Do note that the regular expression should match what is actually passed to the async method - not the fully qualied url.
Parameters:
- ``config`` dictionary of testability.js config options.
Example:
| &{longfetch}= | `Create Dictionary` | url=.*longfetch.* | method=GET |
| @{blacklist}= | `Create List` | ${longfetch} | |
| ${tc}= | `Create Dictionary` | maxTimeout=5000 | blacklist=${blacklist} |
| Set Testability Config | ${tc} | | |
.
"""
self.testability_config = config
@log_wrapper
@keyword
def instrument_browser(self: "SeleniumTestability") -> None:
"""
Instruments the current webpage for testability. This should happen automatically vie SeleniumTestability's internal `Event Firing Webdriver` support but keyword is provided also. Calls `Inject Testability` keyword automatically.
"""
if not self.is_testability_installed():
self._inject_testability()
@log_wrapper
@keyword
def is_testability_installed(self: "SeleniumTestability") -> bool:
"""
Returns True if testability api's are loaded and current browser/window is instrumented, False if not.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["is_installed"])
@log_wrapper
@keyword
def wait_for_document_ready(self: "SeleniumTestability") -> None:
"""
Explicit waits until document.readyState is complete.
"""
self.ctx.driver.execute_async_script(JS_LOOKUP["wait_for_document_ready"])
@log_wrapper
@keyword
def set_testability_automatic_wait(self: "SeleniumTestability", enabled: bool) -> None:
"""
Sets the state to TestabilityListener if it should automically call `Wait For Testability Ready` when interactions are done.
Parameters:
- ``enabled`` state of automatic waits.
"""
self.automatic_wait = enabled
@log_wrapper
@keyword
def enable_testability_automatic_wait(self: "SeleniumTestability") -> None:
"""
Enables TestabilityListener to call `Wait For Testability Ready` onn all interactions that are done.
"""
self.set_testability_automatic_wait(True)
@log_wrapper
@keyword
def disable_testability_automatic_wait(self: "SeleniumTestability") -> None:
"""
Disables TestabilityListener to call `Wait For Testability Ready` onn all interactions that are done.
"""
self.set_testability_automatic_wait(False)
@log_wrapper
@keyword
def wait_for_testability_ready(
self: "SeleniumTestability", timeout: OptionalStrType = None, error_on_timeout: OptionalBoolType = None
) -> None:
"""
Explicitly waits until testability is ready or timeout happens.
Parameters:
- ``timeout`` Amount of time to wait until giving up for testability to be ready. Robot framework timestring
- ``error_on_timeout`` if timeout occurs, should we throw an error
Both parameters are optional, if not provided, default values from plugin initialization time are used.
"""
local_timeout = self.timeout
if timeout is not None:
local_timeout = timestr_to_secs(timeout)
local_error_on_timeout = self.error_on_timeout
if error_on_timeout is not None:
local_error_on_timeout = is_truthy(error_on_timeout)
try:
WebDriverWait(self.ctx.driver, local_timeout, 0.15, ignored_exceptions=[TimeoutException]).until(
lambda x: self.ctx.driver.execute_async_script(JS_LOOKUP["wait_for_testability"])
)
except TimeoutException:
if local_error_on_timeout:
raise TimeoutException("Timed out waiting for testability ready callback to trigger.")
except Exception as e:
self.warn(e)
@log_wrapper
@keyword
def set_testability_timeout(self: "SeleniumTestability", timeout: str) -> str:
"""
Sets the global timeout value for waiting testability ready. Overrides the defaults set from plugin parameters.
Parameters:
- ``timeout`` Amount of time to wait until giving up for testability to be ready. Robot framework timestring
"""
current = self.timeout
self.timeout = timeout # type: ignore
return secs_to_timestr(current)
@log_wrapper
@keyword
def get_testability_timeout(self: "SeleniumTestability") -> str:
"""
Returns the global timeout value in robot framework timestr format for waiting testability ready.
"""
return secs_to_timestr(self.timeout)
@log_wrapper
@keyword
def set_testability_error_on_timeout(self: "SeleniumTestability", error_on_timeout: bool) -> None:
"""Sets the global error_on_timeout value. eg, should SeleniumTestability throw exception when timeout occurs and there are still events in the testability queue.
Parameters:
- ``error_on_timeout`` - any value that robot framework considers truthy can be provided here.
"""
self.error_on_timeout = error_on_timeout
@keyword
@log_wrapper
def get_testability_error_on_timeout(self: "SeleniumTestability") -> bool:
"""Returns error_on_timeout value set via plugin parameters or via `Set Testability Error On Timeout`keyword.
"""
return self.error_on_timeout
@staticmethod
@keyword("Add Basic Authentication To Url")
def add_authentication(url: str, user: str, password: str) -> str:
"""
For websites that require basic auth authentication, add user and password into the given url.
Parameters:
- ``url`` - url where user and password should be added to.
- ``user`` - username
- ``password`` - password
"""
data = furl(url)
data.username = user
data.password = password
return data.tostr()
@staticmethod
@keyword
def split_url_to_host_and_path(url: str) -> dict:
"""
Returs given url as dict with property "base" set to a protocol and hostname and "path" as the trailing path.
This is useful when constructing requests sessions from urls used within SeleniumLibrary.
"""
data = furl(url)
return {"base": str(data.copy().remove(path=True)), "path": str(data.path)}
@log_wrapper
@keyword
def set_testability_automatic_injection(self: "SeleniumTestability", enabled: bool) -> None:
"""
Sets the state to TestabilityListener if it should automically inject testability.
Parameters:
- ``enabled`` state of automatic injection
"""
self.automatic_injection = enabled
@log_wrapper
@keyword
def enable_testability_automatic_injection(self: "SeleniumTestability") -> None:
"""
Enables TestabilityListener to automatically inject testability.
"""
self.set_testability_automatic_injection(True)
@log_wrapper
@keyword
def disable_testability_automatic_injection(self: "SeleniumTestability") -> None:
"""
Disables TestabilityListener to automatically inject testability
"""
self.set_testability_automatic_injection(False)
@staticmethod
@keyword
def cookies_to_dict(cookies: str) -> dict: # FIX: cookies can be dict also
"""
Converts a cookie string into python dict.
"""
ret = {}
cookie = SimpleCookie() # type: SimpleCookie
cookie.load(cookies)
for key, morsel in cookie.items():
ret[key] = morsel.value
return ret
@log_wrapper
@keyword
def get_navigator_useragent(self: "SeleniumTestability") -> str:
"""
Returns useragent string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "userAgent")
@log_wrapper
@keyword
def get_navigator_appCodeName(self: "SeleniumTestability") -> str:
"""
Returns appCoedName string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "appCodeName")
@log_wrapper
@keyword
def get_navigator_appname(self: "SeleniumTestability") -> str:
"""
Returns appName string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "appName")
@log_wrapper
@keyword
def get_navigator_appversion(self: "SeleniumTestability") -> str:
"""
Returns appVersion string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "appVersion")
@log_wrapper
@keyword
def get_navigator_cookieenabled(self: "SeleniumTestability") -> bool:
"""
Returns cookieEnabled boolean of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "cookieEnabled")
@log_wrapper
@keyword
def get_navigator_language(self: "SeleniumTestability") -> str:
"""
Returns language string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "language")
@log_wrapper
@keyword
def get_navigator_online(self: "SeleniumTestability") -> bool:
"""
Returns online boolean of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "onLine")
@log_wrapper
@keyword
def get_navigator_platform(self: "SeleniumTestability") -> str:
"""
Returns platform string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "platform")
@log_wrapper
@keyword
def get_navigator_product(self: "SeleniumTestability") -> str:
"""
Returns product string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["navigator"], "product")
@log_wrapper
@keyword
def drag_and_drop(self: "SeleniumTestability", locator: LocatorType, target: LocatorType, html5: bool = False) -> None:
"""Drags element identified by ``locator`` into ``target`` element.
The ``locator`` argument is the locator of the dragged element
and the ``target`` is the locator of the target. See the
`Locating elements` section for details about the locator syntax.
If you wish to drag and drop a file from a local filesystem, you can specify the locator as `file:/full/path/to/filename`
and SeleniumTestability will generate a drag'n'drop events to upload a file into a given `target` element.
``html5`` parameter is optional and if provided, `drag_and_drop`will utilize
javascript to trigger the suitable events ensuring that html5 applications
receive the right events. If `locator` starts with file: prefix, html5 defaults to True.
Example:
| `Drag And Drop` | css:div#element | css:div.target | html5=True |
| `Drag And Drop` | file:/home/rasjani/testfile.txt | id:demo-upload |
"""
file_prefix = "file:"
html5 = is_truthy(html5)
if file_prefix in locator:
html5 = True
if not html5:
self.el.drag_and_drop(locator, target)
else:
to_element = self.el.find_element(target)
filename = None
if type(locator) == str and file_prefix in locator:
filename = locator[locator.startswith(file_prefix) and len(file_prefix):]
if filename is not None:
if Path(filename).exists():
file_input = self.driver.execute_script(JS_LOOKUP["drag_and_drop_file"], to_element, 0, 0)
file_input.send_keys(filename)
else:
raise RuntimeError(f"Unable to upload {filename} - its missing")
else:
from_element = self.el.find_element(locator)
self.ctx.driver.execute_script(JS_LOOKUP["dragdrop"], from_element, to_element)
@log_wrapper
@keyword
def scroll_to_bottom(self: "SeleniumTestability", smooth: bool = False) -> None:
"""
Scrolls current window to the bottom of the page
Parameters:
- ``smooth`` if sets to true, enables smooth scrolling, otherwise instant.
"""
smooth = bool(smooth)
behavior = "smooth" if smooth else "instant"
self.ctx.driver.execute_script(JS_LOOKUP["scroll_to_bottom"], behavior)
@log_wrapper
@keyword
def scroll_to_top(self: "SeleniumTestability", smooth: bool = False) -> None:
"""
Scrolls current window to the top of the page
Parameters:
- ``smooth`` if sets to true, enables smooth scrolling, otherwise instant.
"""
smooth = bool(smooth)
behavior = "smooth" if smooth else "instant"
self.ctx.driver.execute_script(JS_LOOKUP["scroll_to_top"], behavior)
@log_wrapper
@keyword
def toggle_element_visibility(self: "SeleniumTestability", locator: LocatorType) -> None:
"""
Toggles visiblity state of element via ``locator``
"""
if locator in self.hidden_elements:
self.hide_element(locator)
else:
self.show_element(locator)
@log_wrapper
@keyword
def hide_element(self: "SeleniumTestability", locator: LocatorType) -> None:
"""
Hides element via ``locator``. Typically one would use this to avoid getting
Toggles visiblity state of element via ``locator``
past overlays that are on top of element that is to be interacted with.
"""
from_element = self.el.find_element(locator)
current_display = self.ctx.driver.execute_script(JS_LOOKUP["get_style_display"], from_element)
self.hidden_elements[locator] = current_display
self.ctx.driver.execute_script(JS_LOOKUP["set_style_display"], from_element, "none")
@log_wrapper
@keyword
def show_element(self: "SeleniumTestability", locator: LocatorType) -> None:
"""
Shows element via ``locator`` that has been previously been hidden with `Hide Element` keyword.
"""
from_element = self.el.find_element(locator)
state = self.hidden_elements.get(locator, "")
self.ctx.driver.execute_script(JS_LOOKUP["set_style_display"], from_element, state)
del self.hidden_elements[locator]
def _element_blocked(self: "SeleniumTestability", locator: LocatorType) -> bool:
from_element = self.el.find_element(locator)
rect = self.ctx.driver.execute_script(JS_LOOKUP["get_rect"], from_element)
y = rect["y"] + (rect["height"] / 2)
x = rect["x"] + (rect["width"] / 2)
elem = self.ctx.driver.execute_script(JS_LOOKUP["get_element_at"], x, y)
try:
return from_element != elem.wrapped_element
except AttributeError:
return from_element != elem
@log_wrapper
@keyword
def get_webelement_at(self: "SeleniumTestability", x: int, y: int) -> WebElementType:
"""Returns a topmost WebElement at given coordinates"""
element = self.ctx.driver.execute_script(JS_LOOKUP["get_element_at"], x, y)
# NOTE: Maybe we should always return just straight element and not
# really care if its event firing or not?
try:
return element.wrapped_element
except AttributeError:
return element
@log_wrapper
@keyword
def is_element_blocked(self: "SeleniumTestability", locator: LocatorType) -> bool:
"""
Returns `True` is ``locator`` is blocked, `False` if it is not.
Example:
| ${blocked}= | Is Element Blocked | id:some_id | |
| Run Keyword If | ${blocked} == True | Hide Element | id:some_other_id |
This will hide the element with id:some_other_id if element id:some_id is being blocked
"""
return self._element_blocked(locator)
@log_wrapper
@keyword
def element_should_be_blocked(self: "SeleniumTestability", locator: LocatorType) -> None:
"""
Throws exception if element found with ``locator`` is not blocked by any overlays.
Example:
| Element Should Be Blocked | id:some_id |
If nothing is on top of of provided element, throws an exception
"""
is_blocked = self._element_blocked(locator)
if not is_blocked:
raise AssertionError("Element with locator {} is not blocked".format(locator))
@log_wrapper
@keyword
def element_should_not_be_blocked(self: "SeleniumTestability", locator: LocatorType) -> None:
"""
Throws exception if element found with ``locator`` is being blocked by overlays.
Example:
| Element Should Not Be Blocked | id:some_id |
If there's element on top of provided selector, throws an exception
"""
is_blocked = self._element_blocked(locator)
if is_blocked:
raise AssertionError("Element with locator {} is blocked".format(locator))
def _get_ff_log(self: "SeleniumTestability", name: str) -> BrowserLogsType:
matcher = (
r"^(?P<source>JavaScript|console)(\s|\.)(?P<level>warn.*?|debug|trace|log|error|info):\s(?P<message>(?!resource:).*)$"
)
LEVEL_LOOKUP = {
"log": "INFO",
"warn": "WARN",
"warning": "WARN",
"error": "SEVERE",
"info": "INFO",
"trace": "SEVERE",
"debug": "DEBUG",
}
SOURCE_LOOKUP = {"JavaScript": "javascript", "console": "console-api"}
log = []
skip_lines = self.ff_log_pos.get(name, 0)
buff: BrowserLogsType = []
with open(name, "r") as f:
buff = f.read().split("\n")
self.ff_log_pos[name] = skip_lines + len(buff)
buff = buff[skip_lines:]
for line in buff:
matches = re.search(matcher, line)
if matches:
row = {
"level": LEVEL_LOOKUP[matches.group("level")],
"message": matches.group("message"),
"source": SOURCE_LOOKUP[matches.group("source")],
"timestamp": int(time() * 1000),
}
log.append(json.dumps(row))
return log
@log_wrapper
@keyword
def get_log(self: "SeleniumTestability", log_type: str = "browser") -> BrowserLogsType:
"""
Returns logs determined by ``log_type`` from the current browser. What is returned
depends on desired_capabilities passed to `Open Browser`.
Note: On firefox, the firefox profile has to have `devtools.console.stdout.content` property to be set.
This can be done automatically with `Generate Firefox Profile` and then pass that to `Open Browser`.
This keyword will mostly likely not work with remote seleniun driver!
"""
ret = [] # type: BrowserLogsType
try:
if is_firefox(self.ctx.driver) and log_type == "browser":
ret = self._get_ff_log(self.ctx.driver.service.log_file.name)
else:
ret = self.ctx.driver.get_log(log_type)
except WebDriverException:
if not self.browser_warn_shown:
self.browser_warn_shown = True
self.warn("Current browser does not support fetching logs from the browser with log_type: {}".format(log_type))
return []
if not ret and not self.empty_log_warn_shown:
self.empty_log_warn_shown = True
self.warn("No logs available - you might need to enable loggingPrefs in desired_capabilities")
return ret
@log_wrapper
@keyword
def get_default_capabilities(self: "SeleniumTestability", browser_name: str) -> OptionalDictType:
"""
Returns a set of default capabilities for given ``browser``.
"""
try:
browser = browser_name.lower().replace(" ", "")
return self.BROWSERS[browser].copy()
except Exception as e:
self.logger.debug(e)
return None
@log_wrapper
@keyword
def set_element_attribute(self: "SeleniumTestability", locator: LocatorType, attribute: str, value: str) -> None:
"""
Sets ``locator`` attribute ``attribute`` to ``value``
"""
from_element = self.el.find_element(locator)
self.ctx.driver.execute_script(JS_LOOKUP["set_element_attribute"], from_element, attribute, value)
@log_wrapper
@keyword
def get_location_hash(self: "SeleniumTestability") -> str:
"""
returns the fragment identifier of the URL prefexed by a '#'
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "hash")
@log_wrapper
@keyword
def get_location_host(self: "SeleniumTestability") -> str:
"""
returns the hostname and the port of the URL appended by a ':'
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "host")
@log_wrapper
@keyword
def get_location_hostname(self: "SeleniumTestability") -> str:
"""
return the hostname of the URL
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "hostname")
@log_wrapper
@keyword
def get_location_href(self: "SeleniumTestability") -> str:
"""
returns the entire URL
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "href")
@log_wrapper
@keyword
def get_location_origin(self: "SeleniumTestability") -> str:
"""
returns the canonical form of the origin of the specific location
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "origin")
@log_wrapper
@keyword
def get_location_port(self: "SeleniumTestability") -> str:
"""
returns the port number of the URL
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "port")
@log_wrapper
@keyword
def get_location_protocol(self: "SeleniumTestability") -> str:
"""
returns the protocol scheme of the URL
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "protocol")
@log_wrapper
@keyword
def get_location_search(self: "SeleniumTestability") -> str:
"""
returns the sting containing a '?' followed by the parameters or ``querystring`` of the URL
"""
return self.ctx.driver.execute_script(JS_LOOKUP["get_window_location"], "search")
@log_wrapper
@keyword
def generate_firefox_profile(
self: "SeleniumTestability",
preferences: OptionalDictType = None,
accept_untrusted_certs: bool = False,
proxy: OptionalStrType = None,
) -> FirefoxProfile:
"""
Generates a firefox profile that sets up few required preferences for SeleniumTestability to support all necessary features.
Parameters:
- ``preferences`` - firefox profile preferences in dictionary format.
- ``accept_untrusted_certs`` should we accept untrusted/self-signed certificates.
- ``proxy`` proxy options
Note: If you opt out using this keyword, you are not able to get logs with ``Get Logs`` and Firefox.
"""
profile = FirefoxProfile()
if preferences:
for key, value in preferences.items(): # type: ignore
profile.set_preference(key, value)
profile.set_preference("devtools.console.stdout.content", True)
profile.accept_untrusted_certs = accept_untrusted_certs
if proxy:
profile.set_proxy(proxy)
profile.update_preferences()
return profile
@log_wrapper
@keyword
def get_storage_length(self: "SeleniumTestability", storage_type: str = "localStorage") -> int:
"""
Returns a length (# of items) in specified storage.
Parameters:
- ``storage_type`` name of the storage. Valid options: localStorage, sessionStorage
"""
return self.ctx.driver.execute_script(JS_LOOKUP["storage_length"], storage_type)
@log_wrapper
@keyword
def get_storage_keys(self: "SeleniumTestability", storage_type: str = "localStorage") -> StringArray:
"""
Returns a list of keys in specified storage.
Parameters:
- ``storage_type`` name of the storage. Valid options: localStorage, sessionStorage
"""
return self.ctx.driver.execute_script(JS_LOOKUP["storage_keys"], storage_type)
@log_wrapper
@keyword
def get_storage_item(self: "SeleniumTestability", key: str, storage_type: str = "localStorage") -> StorageType:
"""
Returns value of ``key`` from specified storage.
Parameters:
- ``key`` name of the storage key
- ``storage_type`` name of the storage. Valid options: localStorage, sessionStorage
"""
matcher = r"^{.*}$"
storage_item = self.ctx.driver.execute_script(JS_LOOKUP["storage_getitem"], storage_type, key)
if isinstance(storage_item, str) and re.match(matcher, storage_item):
storage_item = json.loads(storage_item)
return storage_item
@log_wrapper
@keyword
def set_storage_item(self: "SeleniumTestability", key: str, value: StorageType, storage_type: str = "localStorage") -> None:
"""
Sets a value to the key in specified storage_type
Parameters:
- ``key`` name of the key
- ``value`` value that should be set to key
- ``storage_type`` name of the storage. Valid options: localStorage, sessionStorage
"""
if isinstance(value, dict):
value = json.dumps(value)
self.ctx.driver.execute_script(JS_LOOKUP["storage_setitem"], storage_type, key, value)
@log_wrapper
@keyword
def clear_storage(self: "SeleniumTestability", storage_type: str = "localStorage") -> None:
"""
Clears all values in specified storage.
Parameters:
- ``storage_type`` name of the storage. Valid options: localStorage, sessionStorage
"""
self.ctx.driver.execute_script(JS_LOOKUP["storage_clear"], storage_type)
@log_wrapper
@keyword
def remove_storage_item(self: "SeleniumTestability", key: str, storage_type: str = "localStorage") -> None:
"""
Removes a key and its value from specified storage
Parameters:
- ``key`` name of the key
- ``storage_type`` name of the storage. Valid options: localStorage, sessionStorage
"""
return self.ctx.driver.execute_script(JS_LOOKUP["storage_removeitem"], storage_type, key)
class SeleniumTestability(LibraryComponent):
"""
SeleniumTestability is plugin for SeleniumLibrary that provides either manual or automatic waiting asyncronous events within SUT. This works by injecting small javascript snippets that can monitor the web application's state and when any supported events are happening within the sut, execution of SeleniumLibrary's keywords are blocked until timeout or those events are processed.
On top of this, there are some more or less useful utilities for web application testing.
TODO: Document constructor variables and Listener
== Usage ==
Example:
| ***** Settings *****
| Library SeleniumLibrary plugins=SeleniumTestability;True;30 Seconds;True
|
| Suite Setup Open Browser https://127.0.0.1:5000/ browser=Firefox
| Suite Teardown Close Browser
|
| ***** Test Cases *****
| Instrument Browser Example
| ${x}= `Testability Loaded`
| Should Be True ${x}
== Waiting ==
There are two modes of waiting, automatic and non-automatic. When automatic waiting is enabled, when SeleniumLibrary keywords are used, plugin waits until all currently running and supported asyncronous events are done before commencing to use the locator.
=== Automatic ===
| ***** Settings *****
| Library SeleniumLibrary plugins=SeleniumTestability;True;30 Seconds;True
|
| Suite Setup Open Browser https://127.0.0.1:5000/ browser=Firefox
| Suite Teardown Close Browser
|
| ***** Test Cases *****
| Basic Example
| Click Element id:fetch-button
| Click Element id:xhr-button
| `Wait For Testability Ready`
In this scenario, test is clicking first element, waits for the fetch call to finish before clicking on the next. Also, do note that in this example, we are calling `Wait For Testability Ready` to also wait for xhr request to finish as there is no other SeleniumLibrary calls after the second click.
=== Non Automatic ===
| ***** Settings *****
| Library SeleniumLibrary plugins=SeleniumTestability;False;30 Seconds;True
|
| Suite Setup Open Browser https://127.0.0.1:5000/ browser=Firefox
| Suite Teardown Close Browser
|
| ***** Test Cases *****
| Basic Example
| Click Element id:fetch-button
| `Wait For Testability Ready`
| Click Element id:xhr-button
| `Wait For Testability Ready`
= Current Features =
- Can detect setTimeout & setImmediate calls and wait for them.
- Can detect fetch() call and wait for it to finish
- Can detect XHR requests and wait for them to finish
- Can detect CSS Animations and wait form them to finish
- Can detect CSS Transitions and wait form them to finish
*Do note* that CSS animations and transitions might not work properly in *Chrome*.
"""
BROWSERS = {
"googlechrome": DesiredCapabilities.CHROME,
"gc": DesiredCapabilities.CHROME,
"chrome": DesiredCapabilities.CHROME,
"headlesschrome": DesiredCapabilities.CHROME,
"ff": DesiredCapabilities.FIREFOX,
"firefox": DesiredCapabilities.FIREFOX,
"headlessfirefox": DesiredCapabilities.FIREFOX,
"ie": DesiredCapabilities.INTERNETEXPLORER,
"internetexplorer": DesiredCapabilities.INTERNETEXPLORER,
"edge": DesiredCapabilities.EDGE,
"opera": DesiredCapabilities.OPERA,
"safari": DesiredCapabilities.SAFARI,
"phantomjs": DesiredCapabilities.PHANTOMJS,
"htmlunit": DesiredCapabilities.HTMLUNIT,
"htmlunitwithjs": DesiredCapabilities.HTMLUNITWITHJS,
"android": DesiredCapabilities.ANDROID,
"iphone": DesiredCapabilities.IPHONE,
}
@property
def automatic_wait(self: "SeleniumTestability") -> bool:
return self.ctx.testability_settings["automatic_wait"]
@automatic_wait.setter
def automatic_wait(self: "SeleniumTestability", value: bool) -> None:
self.ctx.testability_settings["automatic_wait"] = value
@property
def error_on_timeout(self: "SeleniumTestability") -> bool:
return self.ctx.testability_settings["error_on_timeout"]
@error_on_timeout.setter
def error_on_timeout(self: "SeleniumTestability", value: bool) -> None:
self.ctx.testability_settings["error_on_timeout"] = value
@property
def timeout(self: "SeleniumTestability") -> float:
return self.ctx.testability_settings["timeout"]
@timeout.setter
def timeout(self: "SeleniumTestability", value: str) -> None:
self.ctx.testability_settings["timeout"] = timestr_to_secs(value)
@property
def automatic_injection(self: "SeleniumTestability") -> bool:
return self.ctx.testability_settings["automatic_injection"]
@automatic_injection.setter
def automatic_injection(self: "SeleniumTestability", value: bool) -> None:
self.ctx.testability_settings["automatic_injection"] = value
def __init__(
self: "SeleniumTestability",
ctx: SeleniumLibrary,
automatic_wait: bool = True,
timeout: str = "30 seconds",
error_on_timeout: bool = True,
automatic_injection: bool = True,
) -> None:
LibraryComponent.__init__(self, ctx)
self.logger = get_logger("SeleniumTestability")
self.logger.debug("__init__({},{},{},{},{})".format(
ctx, automatic_wait, timeout, error_on_timeout,
automatic_injection))
self.el = ElementKeywords(ctx)
self.CWD = abspath(dirname(__file__))
self.js_bundle = join(self.CWD, "js", "testability.js")
self.ctx.event_firing_webdriver = TestabilityListener
self.ctx.testability_settings = {"testability": self}
self.automatic_wait = automatic_wait
self.automatic_injection = automatic_injection
self.error_on_timeout = error_on_timeout
self.timeout = timeout # type: ignore
self.hidden_elements = {} # type: Dict[str, str]
self.browser_warn_shown = False
self.empty_log_warn_shown = False
self.ff_log_pos = {} # type: Dict[str, int]
@log_wrapper
def _inject_testability(self: "SeleniumTestability") -> None:
"""
Injects SeleniumTestability javascript bindings into a current browser's current window. This should happen automatically vie SeleniumTestability's internal `Event Firing Webdriver` support but keyword is provided also.
"""
with open(self.js_bundle, "r") as f:
buf = f.read()
self.ctx.driver.execute_script("{};".format(buf))
@log_wrapper
@keyword
def instrument_browser(self: "SeleniumTestability") -> None:
"""
Instruments the current webpage for testability. This should happen automatically vie SeleniumTestability's internal `Event Firing Webdriver` support but keyword is provided also. Calls `Inject Testability` keyword automatically.
"""
if not self.is_testability_installed():
self._inject_testability()
@log_wrapper
@keyword
def is_testability_installed(self: "SeleniumTestability") -> bool:
"""
Returns True if testability api's are loaded and current browser/window is instrumented, False if not.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["is_installed"])
@log_wrapper
@keyword
def wait_for_document_ready(self: "SeleniumTestability") -> None:
"""
Explicit waits until document.readyState is complete.
"""
self.ctx.driver.execute_async_script(
JS_LOOKUP["wait_for_document_ready"])
@log_wrapper
@keyword
def set_testability_automatic_wait(self: "SeleniumTestability",
enabled: bool) -> None:
"""
Sets the state to TestabilityListener if it should automically call `Wait For Testability Ready` when interactions are done.
Parameters:
- ``enabled`` state of automatic waits.
"""
self.automatic_wait = enabled
@log_wrapper
@keyword
def enable_testability_automatic_wait(self: "SeleniumTestability") -> None:
"""
Enables TestabilityListener to call `Wait For Testability Ready` onn all interactions that are done.
"""
self.set_testability_automatic_wait(True)
@log_wrapper
@keyword
def disable_testability_automatic_wait(
self: "SeleniumTestability") -> None:
"""
Disables TestabilityListener to call `Wait For Testability Ready` onn all interactions that are done.
"""
self.set_testability_automatic_wait(False)
@log_wrapper
@keyword
def wait_for_testability_ready(
self: "SeleniumTestability",
timeout: OptionalStrType = None,
error_on_timeout: OptionalBoolType = None) -> None:
"""
Explicitly waits until testability is ready or timeout happens.
Parameters:
- ``timeout`` Amount of time to wait until giving up for testability to be ready. Robot framework timestring
- ``error_on_timeout`` if timeout occurs, should we throw an error
Both parameters are optional, if not provided, default values from plugin initialization time are used.
"""
local_timeout = self.timeout
if timeout is not None:
local_timeout = timestr_to_secs(timeout)
local_error_on_timeout = self.error_on_timeout
if error_on_timeout is not None:
local_error_on_timeout = is_truthy(error_on_timeout)
try:
WebDriverWait(
self.ctx.driver, local_timeout,
0.15).until(lambda x: self.ctx.driver.execute_async_script(
JS_LOOKUP["wait_for_testability"]))
except TimeoutException:
if local_error_on_timeout:
raise TimeoutException(
"Timed out waiting for testability ready callback to trigger."
)
except Exception as e:
self.warn(e)
@log_wrapper
@keyword
def set_testability_timeout(self: "SeleniumTestability",
timeout: str) -> str:
"""
Sets the global timeout value for waiting testability ready. Overrides the defaults set from plugin parameters.
Parameters:
- ``timeout`` Amount of time to wait until giving up for testability to be ready. Robot framework timestring
"""
current = self.timeout
self.timeout = timeout # type: ignore
return secs_to_timestr(current)
@log_wrapper
@keyword
def get_testability_timeout(self: "SeleniumTestability") -> str:
"""
Returns the global timeout value in robot framework timestr format for waiting testability ready.
"""
return secs_to_timestr(self.timeout)
@log_wrapper
@keyword
def set_testability_error_on_timeout(self: "SeleniumTestability",
error_on_timeout: bool) -> None:
"""Sets the global error_on_timeout value. eg, should SeleniumTestability throw exception when timeout occurs and there are still events in the testability queue.
Parameters:
- ``error_on_timeout`` - any value that robot framework considers truthy can be provided here.
"""
self.error_on_timeout = error_on_timeout
@keyword
@log_wrapper
def get_testability_error_on_timeout(self: "SeleniumTestability") -> bool:
"""Returns error_on_timeout value set via plugin parameters or via `Set Testability Error On Timeout`keyword.
"""
return self.error_on_timeout
@staticmethod
@keyword("Add Basic Authentication To Url")
def add_authentication(url: str, user: str, password: str) -> str:
"""
For websites that require basic auth authentication, add user and password into the given url.
Parameters:
- ``url`` - url where user and password should be added to.
- ``user`` - username
- ``password`` - password
"""
data = furl(url)
data.username = user
data.password = password
return data.tostr()
@staticmethod
@keyword
def split_url_to_host_and_path(url: str) -> dict:
"""
Returs given url as dict with property "base" set to a protocol and hostname and "path" as the trailing path.
This is useful when constructing requests sessions from urls used within SeleniumLibrary.
"""
data = furl(url)
return {
"base": str(data.copy().remove(path=True)),
"path": str(data.path)
}
@log_wrapper
@keyword
def set_testability_automatic_injection(self: "SeleniumTestability",
enabled: bool) -> None:
"""
Sets the state to TestabilityListener if it should automically inject testability.
Parameters:
- ``enabled`` state of automatic injection
"""
self.automatic_injection = enabled
@log_wrapper
@keyword
def enable_testability_automatic_injection(
self: "SeleniumTestability") -> None:
"""
Enables TestabilityListener to automatically inject testability.
"""
self.set_testability_automatic_injection(True)
@log_wrapper
@keyword
def disable_testability_automatic_injection(
self: "SeleniumTestability") -> None:
"""
Disables TestabilityListener to automatically inject testability
"""
self.set_testability_automatic_injection(False)
@staticmethod
@keyword
def cookies_to_dict(cookies: str) -> dict: # FIX: cookies can be dict also
"""
Converts a cookie string into python dict.
"""
ret = {}
cookie = SimpleCookie()
cookie.load(cookies)
for key, morsel in cookie.items():
ret[key] = morsel.value
return ret
@log_wrapper
@keyword
def get_current_useragent(self: "SeleniumTestability") -> str:
"""
Returns useragent string of current browser.
"""
return self.ctx.driver.execute_script(JS_LOOKUP["useragent"])
@log_wrapper
@keyword
def drag_and_drop(self: "SeleniumTestability",
locator: LocatorType,
target: LocatorType,
html5: bool = False) -> None:
"""Drags element identified by ``locator`` into ``target`` element.
The ``locator`` argument is the locator of the dragged element
and the ``target`` is the locator of the target. See the
`Locating elements` section for details about the locator syntax.
``html5`` parameter is optional and if provided, `drag_and_drop`will utilize
javascript to trigger the suitable events ensuring that html5 applications
receive the right events
Example:
| `Drag And Drop` | css:div#element | css:div.target | True |
"""
html5 = is_truthy(html5)
if not html5:
self.el.drag_and_drop(locator, target)
else:
from_element = self.el.find_element(locator)
to_element = self.el.find_element(target)
self.ctx.driver.execute_script(JS_LOOKUP["dragdrop"], from_element,
to_element)
@log_wrapper
@keyword
def scroll_to_bottom(self: "SeleniumTestability") -> None:
"""
Scrolls current window to the bottom of the page
"""
self.ctx.driver.execute_script(JS_LOOKUP["scroll_to_bottom"])
@log_wrapper
@keyword
def scroll_to_top(self: "SeleniumTestability") -> None:
"""
Scrolls current window to the bottom of the page
"""
self.ctx.driver.execute_script(JS_LOOKUP["scroll_to_top"])
@log_wrapper
@keyword
def toggle_element_visibility(self: "SeleniumTestability",
locator: LocatorType) -> None:
"""
Toggles visiblity state of element via ``locator``
"""
if locator in self.hidden_elements:
self.hide_element(locator)
else:
self.show_element(locator)
@log_wrapper
@keyword
def hide_element(self: "SeleniumTestability",
locator: LocatorType) -> None:
"""
Hides element via ``locator``. Typically one would use this to avoid getting
Toggles visiblity state of element via ``locator``
past overlays that are on top of element that is to be interacted with.
"""
from_element = self.el.find_element(locator)
current_display = self.ctx.driver.execute_script(
JS_LOOKUP["get_style_display"], from_element)
self.hidden_elements[locator] = current_display
self.ctx.driver.execute_script(JS_LOOKUP["set_style_display"],
from_element, "none")
@log_wrapper
@keyword
def show_element(self: "SeleniumTestability",
locator: LocatorType) -> None:
"""
Shows element via ``locator`` that has been previously been hidden with `Hide Element` keyword.
"""
from_element = self.el.find_element(locator)
state = self.hidden_elements.get(locator, "")
self.ctx.driver.execute_script(JS_LOOKUP["set_style_display"],
from_element, state)
del self.hidden_elements[locator]
def _element_blocked(self: "SeleniumTestability",
locator: LocatorType) -> bool:
from_element = self.el.find_element(locator)
rect = self.ctx.driver.execute_script(JS_LOOKUP["get_rect"],
from_element)
y = rect["y"] + (rect["height"] / 2)
x = rect["x"] + (rect["width"] / 2)
elem = self.ctx.driver.execute_script(JS_LOOKUP["get_element_at"], x,
y)
try:
return from_element != elem.wrapped_element
except AttributeError:
return from_element != elem
@log_wrapper
@keyword
def get_webelement_at(self: "SeleniumTestability", x: int,
y: int) -> WebElementType:
"""Returns a topmost WebElement at given coordinates"""
element = self.ctx.driver.execute_script(JS_LOOKUP["get_element_at"],
x, y)
# NOTE: Maybe we should always return just straight element and not
# really care if its event firing or not?
try:
return element.wrapped_element
except AttributeError:
return element
@log_wrapper
@keyword
def is_element_blocked(self: "SeleniumTestability",
locator: LocatorType) -> bool:
"""
Returns `True` is ``locator`` is blocked, `False` if it is not.
Example:
| ${blocked}= | Is Element Blocked | id:some_id | |
| Run Keyword If | ${blocked} == True | Hide Element | id:some_other_id |
This will hide the element with id:some_other_id if element id:some_id is being blocked
"""
return self._element_blocked(locator)
@log_wrapper
@keyword
def element_should_be_blocked(self: "SeleniumTestability",
locator: LocatorType) -> None:
"""
Throws exception if element found with ``locator`` is not blocked by any overlays.
#TODO: Add examples
"""
is_blocked = self._element_blocked(locator)
if not is_blocked:
raise AssertionError(
"Element with locator {} is not blocked".format(locator))
@log_wrapper
@keyword
def element_should_not_be_blocked(self: "SeleniumTestability",
locator: LocatorType) -> None:
"""
Throws exception if element found with ``locator`` is being blocked by overlays.
#TODO: Add examples
"""
is_blocked = self._element_blocked(locator)
if is_blocked:
raise AssertionError(
"Element with locator {} is blocked".format(locator))
def _get_ff_log(self: "SeleniumTestability", name: str) -> BrowserLogsType:
matcher = r"^(?P<source>JavaScript|console)(\s|\.)(?P<level>warn.*?|debug|trace|log|error|info):\s(?P<message>.*)$"
LEVEL_LOOKUP = {
"log": "INFO",
"warn": "WARN",
"warning": "WARN",
"error": "SEVERE",
"info": "INFO",
"trace": "SEVERE",
"debug": "DEBUG",
}
SOURCE_LOOKUP = {"JavaScript": "javascript", "console": "console-api"}
log = []
skip_lines = self.ff_log_pos.get(name, 0)
buff = []
with open(name, "r") as f:
buff = f.read().split("\n")
self.ff_log_pos[name] = skip_lines + len(buff)
buff = buff[skip_lines:]
for line in buff:
matches = re.search(matcher, line)
if matches:
row = {
"level": LEVEL_LOOKUP[matches.group("level")],
"message": matches.group("message"),
"source": SOURCE_LOOKUP[matches.group("source")],
"timestamp": int(time() * 1000),
}
log.append(json.dumps(row))
return log
@log_wrapper
@keyword
def get_log(self: "SeleniumTestability",
log_type: str = "browser") -> BrowserLogsType:
"""
Returns logs determined by ``log_type`` from the current browser. What is returned
depends on desired_capabilities passed to `Open Browser`.
Note: On firefox, the firefox profile has to have `devtools.console.stdout.content` property to be set.
This can be done automatically with `Generate Firefox Profile` and then pass that to `Open Browser`.
"""
ret = [] # type: BrowserLogsType
try:
if is_firefox(self.ctx.driver) and log_type == "browser":
ret = self._get_ff_log(self.ctx.driver.service.log_file.name)
else:
ret = self.ctx.driver.get_log(log_type)
except WebDriverException:
if not self.browser_warn_shown:
self.browser_warn_shown = True
self.warn(
"Current browser does not support fetching logs from the browser with log_type: {}"
.format(log_type))
return []
if not ret and not self.empty_log_warn_shown:
self.empty_log_warn_shown = True
self.warn(
"No logs available - you might need to enable loggingPrefs in desired_capabilities"
)
return ret
@log_wrapper
@keyword
def get_default_capabilities(self: "SeleniumTestability",
browser_name: str) -> OptionalDictType:
"""
Returns a set of default capabilities for given ``browser``.
"""
try:
browser = browser_name.lower().replace(" ", "")
return self.BROWSERS[browser].copy()
except Exception as e:
self.logger.debug(e)
return None
@log_wrapper
@keyword
def set_element_attribute(self: "SeleniumTestability",
locator: LocatorType, attribute: str,
value: str) -> None:
"""
Sets ``locator`` attribute ``attribute`` to ``value``
"""
from_element = self.el.find_element(locator)
self.ctx.driver.execute_script(JS_LOOKUP["set_element_attribute"],
from_element, attribute, value)
@log_wrapper
@keyword
def generate_firefox_profile(
self: "SeleniumTestability",
options: OptionalDictType = None,
accept_untrusted_certs: bool = False,
proxy: OptionalStrType = None,
) -> FirefoxProfile:
profile = FirefoxProfile()
if options:
for key, value in options.items(): # type: ignore
profile.set_preference(key, value)
profile.set_preference("devtools.console.stdout.content", True)
if accept_untrusted_certs:
profile.accept_untrusted_certs
if proxy:
profile.set_proxy(proxy)
profile.update_preferences()
return profile
