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)