def render_status_by_id(self, *render_ids):
# type: (*Text) -> List[RenderStatusResults]
argument_guard.not_none(render_ids)
if self._render_info is None:
raise EyesError("render_info must be fetched first")
headers = ServerConnector.DEFAULT_HEADERS.copy()
headers["Content-Type"] = "application/json"
headers["X-Auth-Token"] = self._render_info.access_token
url = urljoin(self._render_info.service_url, self.RENDER_STATUS)
response = self._com.request(
requests.post,
url,
use_api_key=False,
headers=headers,
data=json.dumps(render_ids),
)
if not response.ok:
raise EyesError(
"Error getting server status, {} {}".format(
response.status_code, response.content
)
)
# TODO: improve parser to handle similar names
return json_utils.attr_from_response(response, RenderStatusResults)
def match_window(self, running_session, match_data):
# type: (RunningSession, MatchWindowData) -> MatchResult
"""
Matches the current window to the immediate expected window in the Eyes server.
Notice that a window might be matched later at the end of the test, even if it
was not immediately matched in this call.
:param running_session: The current session that is running.
:param match_data: The data for the requests.post.
:return: The parsed response.
"""
logger.debug("match_window called. {}".format(running_session))
# logger.debug("Data length: %d, data: %s" % (len(data), repr(data)))
if not self.is_session_started:
raise EyesError("Session not started")
data = prepare_match_data(match_data)
# Using the default headers, but modifying the "content type" to binary
headers = ServerConnector.DEFAULT_HEADERS.copy()
headers["Content-Type"] = "application/octet-stream"
# TODO: allow to send images as base64
response = self._com.long_request(
requests.post,
url_resource=urljoin(self.API_SESSIONS_RUNNING, running_session.id),
data=data,
headers=headers,
)
match_result = json_utils.attr_from_response(response, MatchResult)
return match_result
def stop_session(self, running_session, is_aborted, save):
# type: (RunningSession, bool, bool) -> TestResults
"""
Stops a running session in the Eyes server.
:param running_session: The session to stop.
:param is_aborted: Whether the server should mark this session as aborted.
:param save: Whether the session should be automatically saved if it is not aborted.
:return: Test results of the stopped session.
"""
logger.debug("stop_session called.")
if not self.is_session_started:
raise EyesError("Session not started")
params = {"aborted": is_aborted, "updateBaseline": save}
response = self._com.long_request(
requests.delete,
url_resource=urljoin(self.API_SESSIONS_RUNNING, running_session.id),
params=params,
headers=ServerConnector.DEFAULT_HEADERS,
)
test_results = json_utils.attr_from_response(response, TestResults)
logger.debug("stop_session(): parsed response: {}".format(test_results))
# mark that session isn't started
self._is_session_started = False
return test_results
def _start_session(self, session_start_info):
# type: (SessionStartInfo) -> RunningSession
logger.debug("start_session called.")
data = json_utils.to_json(session_start_info)
response = self._com.long_request(
"post",
url_resource=self.API_SESSIONS_RUNNING,
data=data,
headers=self.DEFAULT_HEADERS,
)
running_session = json_utils.attr_from_response(response, RunningSession)
self._is_session_started = True
return running_session
def render_info(self):
# type: () -> Optional[RenderingInfo]
logger.debug("render_info() called.")
headers = ServerConnector.DEFAULT_HEADERS.copy()
headers["Content-Type"] = "application/json"
response = self._com.long_request("get", self.RENDER_INFO_PATH, headers=headers)
if not response.ok:
raise EyesError(
"Cannot get render info: \n Status: {}, Content: {}".format(
response.status_code, response.content
)
)
self._render_info = json_utils.attr_from_response(response, RenderingInfo)
return self._render_info
def start_session(self, session_start_info):
# type: (SessionStartInfo) -> RunningSession
"""
Starts a new running session in the agent. Based on the given parameters,
this running session will either be linked to an existing session, or to
a completely new session.
:param session_start_info: The start params for the session.
:return: Represents the current running session.
"""
logger.debug("start_session called.")
data = json_utils.to_json(session_start_info)
response = self._com.request(
requests.post, url_resource=self.API_SESSIONS_RUNNING, data=data
)
running_session = json_utils.attr_from_response(response, RunningSession)
running_session.is_new_session = response.status_code == requests.codes.created
self._is_session_started = True
return running_session
def match_window(self, running_session, match_data):
# type: (RunningSession, MatchWindowData) -> MatchResult
"""
Matches the current window to the immediate expected window in the Eyes server.
Notice that a window might be matched later at the end of the test, even if it
was not immediately matched in this call.
:param running_session: The current session that is running.
:param match_data: The data for the requests.post.
:return: The parsed response.
"""
logger.debug("match_window called. {}".format(running_session))
# logger.debug("Data length: %d, data: %s" % (len(data), repr(data)))
if not self.is_session_started:
raise EyesError("Session not started")
app_output = match_data.app_output
# when screenshot_url is present we don't need to upload again
if app_output.screenshot_url is None and app_output.screenshot_bytes:
app_output.screenshot_url = self.try_upload_image(
match_data.app_output.screenshot_bytes)
if app_output.screenshot_url is None:
raise EyesError(
"MatchWindow failed: could not upload image to storage service."
)
logger.info("Screenshot image URL: {}".format(
app_output.screenshot_url))
data = json_utils.to_json(match_data)
headers = ServerConnector.DEFAULT_HEADERS.copy()
response = self._com.long_request(
"post",
url_resource=urljoin(self.API_SESSIONS_RUNNING,
running_session.id),
data=data,
headers=headers,
)
return json_utils.attr_from_response(response, MatchResult)
def render(self, *render_requests):
# type: (*RenderRequest) -> List[RunningRender]
logger.debug("render called with {}".format(render_requests))
if self._render_info is None:
raise EyesError("render_info must be fetched first")
url = urljoin(self._render_info.service_url, self.RENDER)
headers = ServerConnector.DEFAULT_HEADERS.copy()
headers["Content-Type"] = "application/json"
headers["X-Auth-Token"] = self._render_info.access_token
data = json_utils.to_json(render_requests)
response = self._com.request(
requests.post, url, use_api_key=False, headers=headers, data=data
)
if response.ok or response.status_code == requests.codes.not_found:
return json_utils.attr_from_response(response, RunningRender)
raise EyesError(
"ServerConnector.render - unexpected status ({})\n\tcontent{}".format(
response.status_code, response.content
)
)
