def request(self, method, url_resource, use_api_key=True, **kwargs):
# type: (Callable, Text, bool, **Any) -> Response
if url_resource is not None:
# makes URL relative
url_resource = url_resource.lstrip("/")
url_resource = urljoin(self.server_url, url_resource)
params = {}
if use_api_key:
params["apiKey"] = self.api_key
params.update(kwargs.get("params", {}))
headers = kwargs.get("headers", self.headers).copy()
timeout_sec = kwargs.get("timeout", None)
if timeout_sec is None:
timeout_sec = datetime_utils.to_sec(self.timeout_ms)
response = method(
url_resource,
data=kwargs.get("data", None),
verify=False,
params=params,
headers=headers,
timeout=timeout_sec,
)
try:
response.raise_for_status()
except requests.HTTPError as e:
logger.exception(e)
return response
def create_dom_snapshot(
driver,
dont_fetch_resources,
skip_resources,
timeout_ms,
cross_origin_rendering,
):
# type: (EyesWebDriver, bool, List[Text], int, bool) -> Dict
is_ie = driver.user_agent.is_internet_explorer
script_type = DomSnapshotScriptForIE if is_ie else DomSnapshotScriptGeneric
script = script_type(driver)
is_ios = "ios" in driver.desired_capabilities.get("platformName",
"").lower()
chunk_byte_length = MAX_CHUNK_BYTES_IOS if is_ios else MAX_CHUNK_BYTES_GENERIC
deadline = time() + datetime_utils.to_sec(timeout_ms)
return create_cross_frames_dom_snapshots(
driver.switch_to,
script,
deadline,
SCRIPT_POLL_INTERVAL_MS,
chunk_byte_length,
cross_origin_rendering,
dont_fetch_resources=dont_fetch_resources,
skip_resources=skip_resources,
serialize_resources=True,
)
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.debug("Upload Status Code: {}".format(response.status_code))
return True
raise EyesError(
"Failed to Upload. Status Code: {}".format(response.status_code)
)
def request(
self, method, url_resource, use_api_key=True, request_id=None, **kwargs
):
# type: (Text, Text, bool, Optional[UUID], **Any) -> Response
req_id = str(uuid.uuid4() if request_id is None else request_id)
if url_resource is not None:
# makes URL relative
url_resource = url_resource.lstrip("/")
url_resource = urljoin(self.server_url.rstrip("/"), url_resource)
params = {}
if use_api_key:
params["apiKey"] = self.api_key
params.update(kwargs.get("params", {}))
headers = self.headers.copy()
headers.update(kwargs.get("headers", {}))
headers["x-applitools-eyes-client-request-id"] = req_id
timeout_sec = kwargs.get("timeout", None)
if timeout_sec is None:
timeout_sec = datetime_utils.to_sec(self.timeout_ms)
response = self.client_session.request(
method,
url_resource,
data=kwargs.get("data", None),
verify=False,
params=params,
headers=headers,
timeout=timeout_sec,
)
try:
response.raise_for_status()
except requests.HTTPError as e:
logger.exception(e)
logger.error("Error response content is: {}".format(response.text))
return response
def start_timer():
def set_timer():
is_check_timer_timeout.append(True)
timer = threading.Timer(datetime_utils.to_sec(dom_extraction_timeout),
set_timer)
timer.daemon = True
timer.setName(timer_name)
timer.start()
return timer
def download_resource(self, url):
# type: (Text) -> Response
logger.debug("Fetching {}...".format(url))
headers = ServerConnector.DEFAULT_HEADERS.copy()
headers["Accept-Encoding"] = "identity"
timeout_sec = datetime_utils.to_sec(self._com.timeout_ms)
response = requests.get(url, headers=headers, timeout=timeout_sec, verify=False)
if response.status_code == requests.codes.not_acceptable:
response = requests.get(url, timeout=timeout_sec, verify=False)
return response
def download_resource(self, url):
# type: (Text) -> Response
headers = {
"Accept-Encoding": "identity",
"Accept-Language": "*",
}
if self._ua_string:
headers["User-Agent"] = self._ua_string
logger.debug("Fetching URL {}\nwith headers {}".format(url, headers))
timeout_sec = datetime_utils.to_sec(self._com.timeout_ms)
response = requests.get(url, headers=headers, timeout=timeout_sec, verify=False)
if response.status_code == requests.codes.not_acceptable:
response = requests.get(url, timeout=timeout_sec, verify=False)
return response
def download_resource(self, url, cookies):
# type: (Text, Dict) -> Response
headers = {
"Accept-Encoding": "identity",
"Accept-Language": "*",
}
cookies = {c["name"]: c["value"] for c in cookies}
if self._ua_string:
headers["User-Agent"] = self._ua_string
logger.debug("Fetching URL {}\nwith headers {}".format(url, headers))
timeout_sec = datetime_utils.to_sec(self._com.timeout_ms)
try:
return self._try_download_resources(headers, timeout_sec, url, cookies)
except (requests.HTTPError, requests.ConnectionError) as e:
logger.warning("Failed to download resource", url=url, exc=e)
response = Response()
response._content = b""
response.status_code = requests.codes.no_response
return response
def __init__(
self,
driver, # type: EyesWebDriver
script, # type: DomSnapshotScript
logger, # type: BoundLogger
timeout_ms, # type: int
chunk_byte_length, # type: int
cross_origin_rendering, # type: bool
use_cookies, # type: bool
**script_args # type: Any
):
self.should_skip_failed_frames = False
self._driver = driver
self._script = script
self._logger = logger
self._deadline_time = time() + datetime_utils.to_sec(timeout_ms)
self._chunk_byte_length = chunk_byte_length
self._cross_origin_rendering = cross_origin_rendering
self._use_cookies = use_cookies
self._script_args = script_args
def test_request_with_changed_values(configured_connector):
new_timeout = 99999
new_timeout_sec = to_sec(new_timeout)
new_api_key = "NEW API KEY"
new_server_url = "http://new-server.com/"
conf = Configuration(timeout=new_timeout,
api_key=new_api_key,
server_url=new_server_url)
configured_connector.update_config(conf, "eyes.test")
with patch("applitools.core.server_connector.ClientSession.request"
) as mocked_request:
with patch(
"applitools.core.server_connector.json_utils.attr_from_response",
return_value=RUNNING_SESSION_OBJ,
):
configured_connector.start_session(SESSION_START_INFO_OBJ)
assert mocked_request.call_args[1]["timeout"] == new_timeout_sec
assert mocked_request.call_args[1]["params"]["apiKey"] == new_api_key
assert new_server_url in mocked_request.call_args[0][1]
