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 ) )