def abort(self): # type: () -> None """ If a test is running, aborts it. Otherwise, does nothing. """ if self.configuration.is_disabled: logger.debug("abort(): ignored (disabled)") return try: self._reset_last_screenshot() if self._running_session: logger.debug("abort(): Aborting session...") try: self._server_connector.stop_session( self._running_session, True, False ) logger.info("--- Test aborted.") except EyesError as e: logger.info("Failed to abort server session: %s " % e) pass finally: self._running_session = None finally: logger.close()
def set_browser_size(driver, required_size): # type: (AnyWebDriver, ViewPort) -> bool if is_mobile_platform(driver): return True previous_size = get_window_size(driver) current_size = None set_window_size(driver, required_size) for _ in range(10): # Poll up to 1 second until window is resized datetime_utils.sleep(100) current_size = get_window_size(driver) if current_size != previous_size: if current_size == required_size: logger.debug("set_browser_size succeeded", current_size=current_size) return True else: # Window size probably have exceeded minimal size or screen resolution # and was adjusted to fit these constraints break logger.info( "set_browser_size failed", required_size=required_size, previous_size=previous_size, current_size=current_size, ) return False
def open( self, driver, # type: AnyWebDriver app_name=None, # type: Optional[Text] test_name=None, # type: Optional[Text] viewport_size=None, # type: Optional[ViewPort] ): # type: (...) -> Optional[EyesWebDriver] """ Starts a test. :param driver: The driver that controls the browser hosting the application under the test. :param app_name: The name of the application under test. :param test_name: The test name. :param viewport_size: The client's viewport size (i.e., the visible part of the document's body) or None to allow any viewport size. :raise EyesError: If the session was already open. """ if self.configure.is_disabled: logger.info("open(): ignored (disabled)") return if app_name: self.configure.app_name = app_name if test_name: self.configure.test_name = test_name if viewport_size: self.configure.viewport_size = viewport_size # type: ignore self._init_driver(driver) result = self._current_eyes.open(self.driver) self._is_opened = True return result
def open(self, driver): # type: (EyesWebDriver) -> EyesWebDriver self._test_uuid = uuid.uuid4() argument_guard.not_none(driver) logger.debug("VisualGridEyes.open(%s)" % self.configure) self._driver = driver self._set_viewport_size() self.server_connector.update_config( self.configure, self.full_agent_id, ua_string=self.driver.user_agent.origin_ua_string, ) self.server_connector.render_info() self.vg_manager.rendering_service.maybe_set_server_connector( self.server_connector) for browser_info, job_info in self._job_info_for_browser_info( self.configure.browsers_info): test = RunningTest( self._create_vgeyes_connector(browser_info, job_info), self.configure.clone(), browser_info, self.vg_manager.rendering_service, ) test.on_results_received(self.vg_manager.aggregate_result) test.test_uuid = self._test_uuid self.test_list.append(test) test.becomes_not_opened() self._is_opened = True self.vg_manager.open(self) logger.info("VisualGridEyes opening {} tests...".format( len(self.test_list))) return driver
def _ensure_element_visible(self, element): if self._target_element is None: # No element? we must be checking the window. return None if self.driver.is_mobile_platform: logger.debug( "NATIVE context identified, skipping 'ensure element visible'") return None original_fc = self.driver.frame_chain.clone() switch_to = self.driver.switch_to eyes_element = EyesWebElement(element, self.driver) element_bounds = eyes_element.bounds current_frame_offset = original_fc.current_frame_offset element_bounds.offset(current_frame_offset.x, current_frame_offset.y) viewport_bounds = self._get_viewport_scroll_bounds() logger.info("viewport_bounds: {}; element_bounds: {}".format( viewport_bounds, element_bounds)) if not element_bounds.contains(viewport_bounds): self._ensure_frame_visible() element_location = Point.from_(element.location) if len(original_fc ) > 0 and element is not original_fc.peek.reference: switch_to.frames(original_fc) scroll_root_element = self.driver.find_element_by_tag_name( "html") else: scroll_root_element = self.scroll_root_element position_provider = self._element_position_provider_from( scroll_root_element) position_provider.set_position(element_location)
def abort(self): # type: () -> Optional[TestResults] """ If a test is running, aborts it. Otherwise, does nothing. """ if self.configure.is_disabled: logger.debug("abort(): ignored (disabled)") return try: self._reset_last_screenshot() if self._running_session: results_url = self._running_session.url logger.debug("abort(): Aborting session...") try: logger.info( "--- Test aborted. \n\tSee details at {}".format( results_url)) results = self._server_connector.stop_session( self._running_session, True, False) results.url = results_url return results except EyesError as e: logger.info("Failed to abort server session: %s " % e) pass finally: self._running_session = None finally: logger.close()
def _upload_data( self, data_bytes, rendering_info, target_url, content_type, media_type ): # type: (bytes, RenderingInfo, Text, Text, Text) -> bool headers = ServerConnector.DEFAULT_HEADERS.copy() headers["Content-Type"] = content_type headers["Content-Length"] = str(len(data_bytes)) headers["Media-Type"] = media_type headers["X-Auth-Token"] = rendering_info.access_token headers["x-ms-blob-type"] = "BlockBlob" timeout_sec = datetime_utils.to_sec(self._com.timeout_ms) response = self.client_session.request( "put", target_url, data=data_bytes, headers=headers, timeout=timeout_sec, verify=False, ) if response.status_code in [requests.codes.ok, requests.codes.created]: logger.info("Upload Status Code: {}".format(response.status_code)) return True raise EyesError( "Failed to Upload Image. Status Code: {}".format(response.status_code) )
def _get_region_in_screenshot(self, region, image, pixel_ratio): # type: (Region, Image, float) -> Region if region.is_size_empty: return region logger.info("Creating screenshot object...") # We need the screenshot to be able to convert the region to screenshot coordinates. screenshot = self.screenshot_factory.make_screenshot( image ) # type: EyesWebDriverScreenshot logger.info("Getting region in screenshot...") region_in_screenshot = screenshot.intersected_region( region, CoordinatesType.SCREENSHOT_AS_IS ) logger.info("Region in screenshot: {}".format(region_in_screenshot)) region_in_screenshot = region_in_screenshot.scale(pixel_ratio) logger.info("Scaled region: {}".format(region_in_screenshot)) region_in_screenshot = self.region_position_compensation.compensate_region_position( region_in_screenshot, pixel_ratio ) # Handling a specific case where the region is actually larger than # the screenshot (e.g., when body width/height are set to 100%, and # an internal div is set to value which is larger than the viewport). region_in_screenshot.intersect(Region.from_(image)) logger.info("Region after intersect: {}".format(region_in_screenshot)) return region_in_screenshot
def _entire_element_screenshot(self, scale_provider): # type: (ScaleProvider) -> EyesWebDriverScreenshot logger.info("Entire element screenshot requested") elem_position_provider = self._element_position_provider if elem_position_provider is None: scroll_root_element = self.driver.find_element_by_tag_name("html") elem_position_provider = self._element_position_provider_from( scroll_root_element) # TODO: Should be moved in proper place??? if self.driver.frame_chain: if (self._user_agent.browser == BrowserNames.Firefox and self._user_agent.browser_major_version < 60 ) or self._user_agent.browser in ( BrowserNames.Chrome, BrowserNames.HeadlessChrome, BrowserNames.Safari, BrowserNames.Edge, BrowserNames.IE, ): self._region_to_check.left += int( self._driver.frame_chain.peek.location.x) algo = self._create_full_page_capture_algorithm(scale_provider) image = algo.get_stitched_region(self._region_to_check, None, elem_position_provider) return EyesWebDriverScreenshot.create_entire_frame( self._driver, image, RectangleSize.from_(image))
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_frame_chain): 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, None, self.position_provider) return EyesWebDriverScreenshot.create_full_page( self._driver, image, original_frame_position)
def update_scale_ratio(self, image_to_scale_width): viewport_width = self.viewport_size["width"] dces_width = self.top_level_context_entire_size["width"] # If the image's width is the same as the viewport's width or the # top level context's width, no scaling is necessary. allowed_vs_deviation = (viewport_width - self._ALLOWED_VS_DEVIATION <= image_to_scale_width <= viewport_width + self._ALLOWED_VS_DEVIATION) allowed_dces_deviation = (dces_width - self._ALLOWED_DCES_DEVIATION <= image_to_scale_width <= dces_width + self._ALLOWED_DCES_DEVIATION) if allowed_dces_deviation or allowed_vs_deviation: logger.info("Image is already scaled correctly.") self._scale_ratio = 1.0 else: logger.info("Calculating the scale ratio..") self._scale_ratio = 1.0 / self.device_pixel_ratio if self.is_mobile_device: logger.info( "Mobile device, so using 2 step calculation for scale ration..." ) logger.info("Scale ratio based on DRP: {}".format( self._scale_ratio)) self._scale_ratio = self.get_scale_ratio_to_viewport( viewport_width, image_to_scale_width, self._scale_ratio) logger.info("Final scale ratio: {}".format(self.scale_ratio))
def check_region_in_frame( self, frame_reference, # type: FrameReference region, # type: Union[Region,Text,List,Tuple,WebElement,EyesWebElement] tag=None, # type: Optional[Text] match_timeout=-1, # type: int stitch_content=False, # type: bool ): # type: (...) -> MatchResult """ Checks a region within a frame, and returns to the current frame. :param frame_reference: A reference to the frame in which the region should be checked. :param region: Specifying the region to check inside the frame. :param tag: Description of the visual validation checkpoint. :param match_timeout: Timeout for the visual validation checkpoint (milliseconds). :param stitch_content: If `True`, stitch the internal content of the region """ if self.configure.is_disabled: logger.info( "check_region_in_frame_by_selector(): ignored (disabled)") return MatchResult() logger.debug("check_region_in_frame_by_selector('%s')" % tag) return self.check( tag, Target.region(region).frame(frame_reference).stitch_content( stitch_content).timeout(match_timeout), )
def open(self, driver): # type: (EyesWebDriver) -> EyesWebDriver self._test_uuid = uuid.uuid4() if self.configuration.is_disabled: return driver logger.open_() argument_guard.not_none(driver) logger.debug("VisualGridEyes.open(%s)" % self.configuration) self._driver = driver browsers_info = self.configuration.browsers_info if self.configuration.viewport_size: self._set_viewport_size(self.configuration.viewport_size) elif browsers_info: viewports = [bi.viewport_size for bi in browsers_info] if viewports: self.configuration.viewport_size = viewports[0] else: self.configuration.viewport_size = self._get_viewport_size() for b_info in browsers_info: test = RunningTest(self._create_vgeyes_connector(b_info), self.configuration, b_info) test.on_results_received( lambda r: self.vg_manager.aggregate_result(test, r)) test.test_uuid = self._test_uuid self.test_list.append(test) self._is_opened = True self.vg_manager.open(self) logger.info("VisualGridEyes opening {} tests...".format( len(self.test_list))) return driver
def normalize_rotation(driver, image, rotation): # type: (WebDriver, Image, Optional[int]) -> Image """ Rotates the image as necessary. The rotation is either manually forced by passing a non-null rotation, or automatically inferred. :param driver: The underlying driver which produced the screenshot. :param image: The image to normalize. :param rotation: The degrees by which to rotate the image: positive values = clockwise rotation, negative values = counter-clockwise, 0 = force no rotation, null = rotate automatically as needed. :return: A normalized image. """ argument_guard.not_none(driver) argument_guard.not_none(image) normalized_image = image if rotation and rotation != 0: normalized_image = image_utils.rotate_image(image, rotation) else: # Do automatic rotation if necessary try: logger.info("Trying to automatically normalize rotation...") if (eyes_selenium_utils.is_mobile_app(driver) and eyes_selenium_utils.is_landscape_orientation(driver) and image.height > image.width): # For Android, we need to rotate images to the right, # and for iOS to the left. degree = 90 if eyes_selenium_utils.is_android( driver) else -90 normalized_image = image_utils.rotate_image(image, degree) except Exception as e: logger.exception(e) logger.info("Skipped automatic rotation handling.") return normalized_image
def mobile_eyes(request, eyes, ios_desired_capabilities, android_desired_capabilities): selenium_url = ( "https://{username}:{password}@ondemand.saucelabs.com:443/wd/hub". format( username=os.getenv("SAUCE_USERNAME", None), password=os.getenv("SAUCE_ACCESS_KEY", None), )) platform_name = os.getenv("TEST_PLATFORM", None) if platform_name == "Android": desired_caps = android_desired_capabilities else: desired_caps = ios_desired_capabilities mobile_driver = open_webdriver( lambda: appium_webdriver.Remote(command_executor=selenium_url, desired_capabilities=desired_caps), ) if mobile_driver is None: raise WebDriverException("Never created!") yield eyes, mobile_driver # report results try: mobile_driver.execute_script( "sauce:job-result=%s" % str(not request.node.rep_call.failed).lower()) except WebDriverException: logger.info( "Warning: The driver failed to quit properly. Check test and server side logs." ) finally: mobile_driver.quit() eyes.close()
def create_dom_snapshot_loop(script, deadline_time, poll_interval_ms, chunk_byte_length, **script_args): # type: (DomSnapshotScript, float, int, int, **Any) -> Dict chunks = [] result = script.run(**script_args) while result.status is ProcessPageStatus.WIP or ( result.status is ProcessPageStatus.SUCCESS_CHUNKED and not result.done): if time() > deadline_time: raise DomSnapshotTimeout result = script.poll_result(chunk_byte_length) if result.status is ProcessPageStatus.WIP: datetime_utils.sleep(poll_interval_ms, "Waiting for the end of DOM extraction") elif result.status is ProcessPageStatus.SUCCESS_CHUNKED: logger.info("Snapshot chunk {}, {}B".format( len(chunks), len(result.value))) chunks.append(result.value) if result.status is ProcessPageStatus.SUCCESS: return result.value elif result.status.SUCCESS_CHUNKED and result.done: return json.loads("".join(chunks)) elif result.status is ProcessPageStatus.ERROR: raise DomSnapshotScriptError(result.error) else: raise DomSnapshotFailure("Unexpected script result", result)
def get_image(self): image = TakesScreenshotImageProvider(self._eyes).get_image() if self._eyes.is_cut_provider_explicitly_set: return image scale_ratio = self._eyes.device_pixel_ratio original_viewport_size = self._eyes._get_viewport_size() viewport_size = original_viewport_size.scale(scale_ratio) logger.info("logical viewport size: {}".format(original_viewport_size)) force_full_page_screenshot = self._eyes.configure.force_full_page_screenshot if force_full_page_screenshot is not None: if not force_full_page_screenshot: current_frame_chain = self._eyes.driver.frame_chain # type: FrameChain if len(current_frame_chain) == 0: position_provider = ScrollPositionProvider( self._eyes.driver, self._eyes.driver.find_element_by_tag_name("html"), ) loc = position_provider.get_current_position() else: loc = current_frame_chain.default_content_scroll_position loc = loc.scale(scale_ratio) image = image_utils.crop_image( image, Region.from_(loc, viewport_size)) return image
def get_locators(self, visual_locator_settings): # type: (VisualLocatorSettings) -> LOCATORS_TYPE argument_guard.not_none(visual_locator_settings) logger.info( "Get locators with given names: {}".format(visual_locator_settings.names) ) logger.info("Requested viewport screenshot for visual locators..") viewport_screenshot = self._get_viewport_screenshot() self._debug_screenshot_provider.save( viewport_screenshot, "Visual locators: {}".format(visual_locator_settings.names), ) image = image_utils.get_bytes(viewport_screenshot) logger.info("Post visual locators screenshot...") viewport_screenshot_url = self._server_connector.try_upload_image(image) logger.info("Screenshot URL: {}".format(viewport_screenshot_url)) data = VisualLocatorsData( app_name=self._eyes.configure.app_name, image_url=viewport_screenshot_url, first_only=visual_locator_settings.values.is_first_only, locator_names=visual_locator_settings.values.names, ) logger.info("Post visual locators: {}".format(data)) return self._server_connector.post_locators(data)
def _ensure_element_visible(self, element): position_provider = None if self._target_element and not self.driver.is_mobile_app: original_fc = self.driver.frame_chain.clone() eyes_element = EyesWebElement(element, self.driver) element_bounds = eyes_element.bounds current_frame_offset = original_fc.current_frame_offset element_bounds = element_bounds.offset(current_frame_offset) viewport_bounds = self._get_viewport_scroll_bounds() logger.info("viewport_bounds: {}; element_bounds: {}".format( viewport_bounds, element_bounds)) if not viewport_bounds.contains(element_bounds): self._ensure_frame_visible() element_location = Point.from_(element.location) if len(original_fc ) > 0 and element is not original_fc.peek.reference: fc = original_fc self.driver.switch_to.frames(original_fc) scroll_root_element = eyes_selenium_utils.curr_frame_scroll_root_element( self.driver, self._scroll_root_element) else: fc = self.driver.frame_chain.clone() scroll_root_element = self.scroll_root_element position_provider = self._element_position_provider_from( scroll_root_element) state = position_provider.get_state() position_provider.set_position(element_location) yield position_provider if self._target_element and position_provider and not self.driver.is_mobile_app: self.driver.switch_to.frames(fc) position_provider.restore_state(state)
def log_session_results_and_raise_exception(raise_ex, results): logger.info("close(): %s" % results) results_url = results.url scenario_id_or_name = results.name app_id_or_name = results.app_name if results.is_unresolved: if results.is_new: logger.info( "--- New test ended. \n\tPlease approve the new baseline at {}" .format(results_url)) if raise_ex: raise NewTestError(results, scenario_id_or_name, app_id_or_name) else: logger.info( "--- Failed test ended. \n\tSee details at {}".format( results_url)) if raise_ex: raise DiffsFoundError(results, scenario_id_or_name, app_id_or_name) elif results.is_failed: logger.info("--- Failed test ended. \n\tSee details at {}".format( results_url)) if raise_ex: raise TestFailedError(results, scenario_id_or_name, app_id_or_name) # Test passed logger.info( "--- Test passed. \n\tSee details at {}".format(results_url))
def _update_scaling_params(self): # type: () -> Optional[ScaleProvider] if (self.device_pixel_ratio != self._UNKNOWN_DEVICE_PIXEL_RATIO or not isinstance(self._scale_provider, NullScaleProvider)): logger.debug("Device pixel ratio was already changed") return self._scale_provider logger.debug("Trying to extract device pixel ratio...") try: device_pixel_ratio = eyes_selenium_utils.get_device_pixel_ratio( self._driver) except Exception as e: logger.info( "Failed to extract device pixel ratio! Using default. Error %s " % e) device_pixel_ratio = self._DEFAULT_DEVICE_PIXEL_RATIO logger.info("Device pixel ratio: {}".format(device_pixel_ratio)) self._device_pixel_ratio = device_pixel_ratio logger.debug("Setting scale provider...") try: self._scale_provider = ContextBasedScaleProvider( top_level_context_entire_size=self._driver. get_entire_page_size(), viewport_size=self.configure.viewport_size, device_pixel_ratio=device_pixel_ratio, is_mobile_device=False, # TODO: fix scaling for mobile ) # type: ScaleProvider except Exception: # This can happen in Appium for example. logger.info("Failed to set ContextBasedScaleProvider.") logger.info("Using FixedScaleProvider instead...") self._scale_provider = FixedScaleProvider(1 / device_pixel_ratio) logger.info("Done!") return self._scale_provider
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 test_problem_user(self): testcase_result = "Failed" try: logger = self.logger logger.info('Starting Testcase: test_login') driver = self.driver username = self.base.get_data("tc3", "username") password = self.base.get_data("tc3", "password") if driver is not None: #login login = LoginPageTestSteps(driver, logger) navigate = login.navigate_to_login_page() user = login.set_username(username) passd = login.set_password(password) login_btn = login.click_login_button() self.terminate_driver(driver) if (navigate or user or passd or login_btn) is not False: testcase_result = 'Passed' else: logger.info('problem initiating WebDriver') except Exception as e: self.logger.error(e) testcase_result = False self.base.set_result("tc3", "test_result", testcase_result) time.sleep(1) return testcase_result
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 _retry_taking_screenshot( self, user_inputs, # type: UserInputs region, # type: Region tag, # type: Text check_settings, # type: CheckSettings retry_timeout_sec, # type: int source, # type: Optional[Text] ): # type: (...) -> EyesScreenshot start = datetime.now() # Start the retry timer. retry = datetime_utils.to_ms((datetime.now() - start).seconds) # The match retry loop. screenshot = self._taking_screenshot_loop( user_inputs, region, tag, check_settings, retry_timeout_sec, retry, start, source, None, ) # If we're here because we haven't found a match yet, try once more if not self._match_result.as_expected: logger.info("Window mismatch. Retrying...") return self._try_take_screenshot(user_inputs, region, tag, check_settings, source) return screenshot
def _try_take_screenshot( self, user_inputs, # type: UserInputs region, # type: Region tag, # type: Text check_settings, # type: CheckSettings source, # type: Optional[Text] ): # type: (...) -> EyesScreenshot app_output = self._app_output_provider.get_app_output( region, self._last_screenshot, check_settings) current_screenshot_hash = hash(app_output.screenshot) if current_screenshot_hash == self._last_screenshot_hash: logger.info( "Got the same screenshot in retry. Not sending to the server") return app_output.screenshot image_match_settings = self.create_image_match_settings( check_settings, self._eyes) replace_last_if_not_first_run = self._last_screenshot_hash is not None self._match_result = self.perform_match( app_output, tag, replace_last_if_not_first_run, image_match_settings, self._eyes, user_inputs, check_settings=check_settings, source=source, ) self._last_screenshot_hash = current_screenshot_hash return app_output.screenshot
def _check_window_base( self, region_provider, # type: RegionProvider tag=None, # type: Optional[Text] ignore_mismatch=False, # type: bool check_settings=None, # type: CheckSettings source=None, # type: Optional[Text] ): # type: (...) -> MatchResult if self.configure.is_disabled: logger.info("check_window(%s): ignored (disabled)" % tag) return MatchResult(as_expected=True) self._ensure_running_session() self._before_match_window() tag = tag if tag is not None else "" result = self._match_window(region_provider, tag, check_settings, source) if not ignore_mismatch: del self._user_inputs[:] self._last_screenshot = result.screenshot self._after_match_window() self._handle_match_result(result, tag) return result
def abort_async(self): if self.configure.is_disabled: logger.info("abort_async(): ignored (disabled)") return if self._is_visual_grid_eyes: return self._visual_grid_eyes.abort_async() else: return self._selenium_eyes.abort()
def check_image(self, image, tag=None, ignore_mismatch=False): # type: (Union[Image.Image, Text], Optional[Text], bool) -> Optional[bool] if self.configure.is_disabled: return None logger.info("check_image(Image {}, tag {}, ignore_mismatch {}".format( image, tag, ignore_mismatch)) return self._check_image(NULL_REGION_PROVIDER, tag, ignore_mismatch, Target.image(image))
def get_image(self): # type: () -> Image logger.info("Getting screenshot as base64...") screenshot64 = self._eyes.driver.get_screenshot_as_base64() logger.info("Done getting base64! Creating BufferedImage...") image = image_utils.image_from_base64(screenshot64) self._eyes.debug_screenshot_provider.save(image, "initial") return image