def _full_page_screenshot(self, scale_provider):
# type: (ScaleProvider) -> EyesWebDriverScreenshot
logger.info("Full page screenshot requested")
original_fc = self.driver.frame_chain.clone()
if original_fc.size > 0:
original_frame_position = original_fc.default_content_scroll_position
else:
original_frame_position = Point.ZERO()
with self.driver.switch_to.frames_and_back(self._original_fc):
scroll_root_element = eyes_selenium_utils.curr_frame_scroll_root_element(
self.driver)
origin_provider = ScrollPositionProvider(self.driver,
scroll_root_element)
origin_provider.set_position(Point.ZERO())
logger.debug("resetting origin_provider location")
location = self.scroll_root_element.location
size_and_borders = self.scroll_root_element.size_and_borders
region = Region(
location["x"] + size_and_borders.borders["left"],
location["y"] + size_and_borders.borders["top"],
size_and_borders.size["width"],
size_and_borders.size["height"],
)
algo = self._create_full_page_capture_algorithm(scale_provider)
image = algo.get_stitched_region(region, Region.EMPTY(),
self.position_provider)
return EyesWebDriverScreenshot.create_full_page(
self._driver, image, original_frame_position)
def compensate_region_position(self, region, pixel_ratio):
logger.info(str(self._useragent))
logger.info(pixel_ratio)
if (
self._useragent.os == OSNames.Windows
and self._useragent.os_major_version <= 7
):
logger.info("compensating by {} pixels".format(pixel_ratio))
return region.offset(0, pixel_ratio)
if pixel_ratio == 1.0:
return region
if self._useragent.browser_major_version > 60:
return region
driver = self._eyes.driver # type: EyesWebDriver
fc = driver.frame_chain
logger.info("frame_chain size: {}".format(fc.size))
if fc.size > 0:
return region
region = region.offset(0, -math.ceil(pixel_ratio / 2))
if region.width <= 0 or region.height <= 0:
return Region.EMPTY()
return region
def full_frame_or_element_region(check_settings):
logger.debug("check_frame_or_element: {}".format(
self._check_frame_or_element))
if self._check_frame_or_element:
fc = self._ensure_frame_visible()
# FIXME - Scaling should be handled in a single place instead
scale_factory = self._update_scaling_params()
screenshot_image = self._image_provider.get_image()
scale_factory.update_scale_ratio(screenshot_image.width)
self.driver.switch_to.frames(fc)
screenshot = EyesWebDriverScreenshot.create_viewport(
self.driver, screenshot_image)
# TODO HERE
logger.debug("replacing region_to_check")
self._region_to_check = screenshot.frame_window
self._full_region_to_check = Region.EMPTY()
target_region = check_settings.values.target_region
if target_region is None:
target_region = Region.EMPTY()
return target_region
def test_config_cloning():
conf = SeleniumConfiguration()
conf.set_viewport_size({"width": 200, "height": 400})
conf.add_property("hello", "world")
conf.default_match_settings.content_regions.append(Region.EMPTY())
conf.add_browser(200, 400, BrowserType.EDGE_CHROMIUM)
conf.set_visual_grid_options(VisualGridOption("option1", "val"))
cloned_conf = conf.clone()
assert id(conf.properties[0]) != id(cloned_conf.properties[0])
assert id(conf.default_match_settings.content_regions) != id(
cloned_conf.default_match_settings.content_regions
)
assert id(conf._browsers_info[0]) != id(cloned_conf._browsers_info[0])
assert id(conf.viewport_size) != id(cloned_conf.viewport_size)
assert id(conf.visual_grid_options[0]) != id(cloned_conf.visual_grid_options[0])
def _check_element(self, name, check_settings):
element = self._target_element # type: EyesWebElement
scroll_root_element = eyes_selenium_utils.curr_frame_scroll_root_element(
self.driver, self._scroll_root_element)
pos_provider = self._create_position_provider(scroll_root_element)
self._region_to_check = Region.EMPTY()
self._full_region_to_check = Region.EMPTY()
result = None
with eyes_selenium_utils.get_and_restore_state(pos_provider):
with self._ensure_element_visible(element):
pl = element.location
try:
self._check_frame_or_element = True
display_style = element.get_computed_style("display")
if self.configure.hide_scrollbars:
element.hide_scrollbars()
size_and_borders = element.size_and_borders
border_widths = size_and_borders.borders
element_size = size_and_borders.size
use_entire_size = False
if display_style != "inline" and (
element_size["height"] <=
self._effective_viewport["height"]
and element_size["width"] <=
self._effective_viewport["width"]):
self._element_position_provider = ElementPositionProvider(
self.driver, element)
use_entire_size = True
else:
self._element_position_provider = None
element_region = Region(
pl["x"] + border_widths["left"],
pl["y"] + border_widths["top"],
element_size["width"],
element_size["height"],
coordinates_type=CoordinatesType.SCREENSHOT_AS_IS,
)
self._region_to_check = element_region
if use_entire_size:
self._full_region_to_check = Region.from_(
element_region.location,
self._element_position_provider.get_entire_size(),
)
else:
self._full_region_to_check = Region(
left=element_region.left,
top=element_region.top,
width=element_region.width,
height=element_region.height,
)
if not self._effective_viewport.is_size_empty:
self._region_to_check = self._region_to_check.intersect(
self._effective_viewport)
result = self._check_window_base(NULL_REGION_PROVIDER,
name, False,
check_settings)
except Exception as e:
logger.exception(e)
raise e
finally:
if self.configure.hide_scrollbars:
element.return_to_original_overflow()
self._check_frame_or_element = False
self._region_to_check = None
self._element_position_provider = None
return result
def compensate_region_position(self, region, pixel_ratio):
if pixel_ratio == 1.0:
return region
if region.width <= 0 and region.height <= 0:
return Region.EMPTY()
return region.offset(0, math.ceil(pixel_ratio))
