def ensure_sync_with_underlying_driver(eyes_driver, selenium_driver):
# type: (EyesWebDriver, WebDriver) -> None
"""
Checks if frame selected in selenium_driver matches frame_chain in eyes_driver.
If it doesn't, follows parent frames up to default content and then repeats
all the chain of frame selections with eyes_driver.
"""
if not eyes_driver.is_mobile_app:
try:
if eyes_driver.frame_chain.size == 0:
in_sync = _has_no_frame_selected(selenium_driver)
else:
selected_frame = eyes_driver.frame_chain.peek
in_sync = selected_frame.scroll_root_element.is_attached_to_page
except SwitchToParentIsNotSupported:
logger.info(
"Unable to ensure frame chain sync with the underlying driver due to "
"unsupported 'switch to parent frame' call in the driver")
if not in_sync:
try:
_do_sync_with_underlying_driver(eyes_driver, selenium_driver)
except Exception as e:
raise_from(
EyesWebDriverIsOutOfSync(
"EyesWebDriver frame chain is out of sync. "
"Please use web driver returned by Eyes.open call "
"for frame switching."),
e,
)
def ignore(self, *regions):
# type: (Self, *Region) -> Self
""" Adds one or more ignore regions. """
try:
self.values.ignore_regions = self.__regions(
regions, method_name="ignore_regions")
except TypeError as e:
raise_from(TypeError, e)
return self
def accessibility(self, region, type=None): # noqa
""" Adds one accessibility region. """
if type:
argument_guard.is_a(type, AccessibilityRegionType)
try:
self.values.accessibility_regions.append(
self._accessibility_provider_from(region, type))
except TypeError as e:
raise_from(TypeError("Wrong argument in .accessibility()"), e)
return self
def add_browsers(self, *renders_info):
if len(renders_info) == 1 and is_list_or_tuple(renders_info[0]):
renders_info = renders_info[0]
for render_info in renders_info:
try:
self.add_browser(render_info)
except TypeError as e:
raise_from(TypeError("Wrong argument in .add_browsers()"), e)
return self
def ignore(self, *regions, **kwargs):
# type: (Self, *Region, **Optional[CodedRegionPadding]) -> Self
""" Adds one or more ignore regions. """
try:
self.values.ignore_regions = self.__regions(
regions,
method_name="ignore_regions",
padding=kwargs.get("padding"))
except TypeError as e:
raise_from(TypeError, e)
return self
def _swith_to_parent_frame(driver):
# type: (WebDriver) -> None
"""
Switches given driver to the parent frame or raises specific exception
"""
try:
driver.switch_to.parent_frame()
except WebDriverException as e:
if "Method is not implemented" in e.msg:
raise_from(SwitchToParentIsNotSupported, e)
else:
raise
def content(self, *regions):
# type: (Self, *Region) -> Self
""" Shortcut to set the match level to :py:attr:`MatchLevel.CONTENT`. """
if not regions:
self.values.match_level = MatchLevel.CONTENT
return self
try:
self.values.content_regions = self.__regions(
regions, method_name="content_regions")
except TypeError as e:
raise_from(TypeError("Wrong argument in .content()"), e)
return self
def strict(self, *regions, **kwargs):
# type: (Self, *Region, **Optional[CodedRegionPadding]) -> Self
""" Shortcut to set the match level to :py:attr:`MatchLevel.STRICT` if no args """
if not regions:
self.values.match_level = MatchLevel.STRICT
return self
try:
self.values.strict_regions = self.__regions(
regions,
method_name="strict_regions",
padding=kwargs.get("padding"))
except TypeError as e:
raise_from(TypeError("Wrong argument in .strict()"), e)
return self
def get_script_result(self, dont_fetch_resources):
# type: (bool) -> Dict
logger.debug("get_script_result(dont_fetch_resources={})".format(
dont_fetch_resources))
try:
return dom_snapshot_script.create_dom_snapshot(
self.driver,
dont_fetch_resources,
None,
DOM_EXTRACTION_TIMEOUT,
self.configure.enable_cross_origin_rendering,
)
except dom_snapshot_script.DomSnapshotFailure as e:
raise_from(EyesError("Failed to capture dom snapshot"), e)
def __ensure_viewport_size(self):
# type: () -> None
"""
Assign the viewport size we need to be in the default content frame.
"""
if self._is_viewport_size_set:
return
try:
if self.configure.viewport_size is None:
# TODO: ignore if viewport_size settled explicitly
target_size = self._get_viewport_size()
self.configure.viewport_size = target_size
else:
target_size = self.configure.viewport_size
self._set_viewport_size(target_size)
self._is_viewport_size_set = True
except Exception as e:
self._is_viewport_size_set = False
raise_from(EyesError("Viewport has not been setup"), e)
def _set_viewport_size(self):
viewport_size = self.configure.viewport_size
if viewport_size is None:
for render_bi in self.configure.browsers_info:
if isinstance(render_bi,
(DesktopBrowserInfo, RenderBrowserInfo)):
viewport_size = render_bi.viewport_size
break
if viewport_size is None:
self.configure.viewport_size = self._get_viewport_size()
return
self.configure.viewport_size = viewport_size
try:
eyes_selenium_utils.set_viewport_size(self.driver, viewport_size)
except Exception as e:
logger.exception(e)
raise_from(EyesError("Failed to set viewport size"), e)
def floating(self, *args): # noqa
"""
Adds a floating region. Region and max_offset or [max_up_offset, max_down_offset, "
"max_left_offset, max_right_offset] are required parameters.
:param arg1: max_offset | Region
:param arg2: Region | max_up_offset
:param arg3: None | max_down_offset
:param arg4: None | max_left_offset
:param arg5: None | max_right_offset
"""
if len(args) < 2:
raise TypeError("Not enough arguments")
if isinstance(args[0], int) and not isinstance(args[1], int):
max_offset = args[0] # type: int
region = args[1] # type: ignore
bounds = FloatingBounds(
max_up_offset=max_offset,
max_down_offset=max_offset,
max_left_offset=max_offset,
max_right_offset=max_offset,
)
elif (isinstance(args[1], int) and isinstance(args[2], int)
and isinstance(args[3], int) and isinstance(args[4], int)):
region = args[0] # type: ignore
bounds = FloatingBounds(
max_up_offset=args[1],
max_down_offset=args[2],
max_left_offset=args[3],
max_right_offset=args[4],
)
else:
raise TypeError("No type match")
logger.info("Adding Region {} with FloatingBounds {}".format(
region, bounds))
try:
region_or_container = self._floating_provider_from(region, bounds)
except TypeError as e:
raise_from(TypeError("Wrong arguments in .floating()"), e)
self.values.floating_regions.append(region_or_container)
return self
def try_upload_image(self, data):
# type: (bytes) -> Optional[Text]
try:
return self._try_upload_data(data, "image/png", "image/png")
except EyesError as e:
raise_from(EyesError("Failed to Upload Image"), e)
