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
