def test_client_forbidden_when_wrapping(): r = _response({"foo": 1}) to_wrap = GlobusHTTPResponse(r, client=mock.Mock()) GlobusHTTPResponse(to_wrap) # ok with pytest.raises(ValueError): GlobusHTTPResponse(to_wrap, client=mock.Mock()) # not ok
def setUp(self): """ Makes GlobusHTTPResponses wrapped around HTTP responses for testing Uses responses with well formed json, malformed json, and plain text """ super(GlobusHTTPResponseTests, self).setUp() # well formed json self.json_data = {"label1": "value1", "label2": "value2"} json_response = requests.Response() json_response._content = six.b(json.dumps(self.json_data)) json_response.headers["Content-Type"] = "application/json" self.globus_json_response = GlobusHTTPResponse(json_response) # malformed json malformed_response = requests.Response() malformed_response._content = six.b("{") malformed_response.headers["Content-Type"] = "application/json" self.globus_malformed_response = GlobusHTTPResponse(malformed_response) # text self.text_data = "text data" text_response = requests.Response() text_response._content = six.b(self.text_data) text_response.headers["Content-Type"] = "text/plain" self.globus_text_response = GlobusHTTPResponse(text_response)
def __init__(self, *args, **kwargs): GlobusHTTPResponse.__init__(self, *args, **kwargs) # call the helper on everything in the response array self._by_resource_server = dict( (unprocessed_item['resource_server'], _convert_token_info_dict(unprocessed_item)) for unprocessed_item in self.data)
def test_http_headers_from_response(): r1 = _response(headers={"Content-Length": "5"}) assert r1.headers["content-length"] == "5" r2 = GlobusHTTPResponse(r1, client=mock.Mock()) # handle a Response object assert r2.headers["content-length"] == "5" r3 = GlobusHTTPResponse(r2) # wrap another response assert r3.headers["content-length"] == "5"
def test_http_status_code_on_response(): r1 = _response(status=404) assert r1.status_code == 404 r2 = GlobusHTTPResponse(r1, client=mock.Mock()) # handle a Response object assert r2.http_status == 404 r3 = GlobusHTTPResponse(r2) # wrap another response assert r3.http_status == 404
def __init__(self, *args, **kwargs): GlobusHTTPResponse.__init__(self, *args, **kwargs) # call the helper at the top level self._by_resource_server = { self.resource_server: _convert_token_info_dict(self) } # call the helper on everything in 'other_tokens' self._by_resource_server.update( dict((unprocessed_item['resource_server'], _convert_token_info_dict(unprocessed_item)) for unprocessed_item in self.other_tokens))
def test_http_reason_on_response(): r1 = _response(status=404) r2 = GlobusHTTPResponse(r1, client=mock.Mock()) # handle a Response object r3 = GlobusHTTPResponse(r2) # wrap another response assert r1.reason == "Not Found" assert r2.http_reason == "Not Found" assert r3.http_reason == "Not Found" r4 = _response(status=200) r5 = GlobusHTTPResponse(r4, client=mock.Mock()) # handle a Response object r6 = GlobusHTTPResponse(r5) # wrap another response assert r4.reason == "OK" assert r5.http_reason == "OK" assert r6.http_reason == "OK"
def invalid_token(live_api, monkeypatch): if live_api: return else: fake_introspect = Mock(return_value=GlobusHTTPResponse( canned_responses.resp({"active": False}))) monkeypatch.setattr(AuthState, "introspect_token", fake_introspect)
def text_http_response(): text_data = "text data" text_response = _response(text_data, encoding="utf-8", headers={"Content-Type": "text/plain"}) return _TestResponse(text_data, GlobusHTTPResponse(text_response, client=mock.Mock()))
def _convert_token_info_dict( source_dict: GlobusHTTPResponse) -> Dict[str, Any]: """ Extract a set of fields into a new dict for indexing by resource server. Allow for these fields to be `None` when absent: - "refresh_token" - "token_type" """ expires_in = source_dict.get("expires_in", 0) return { "scope": source_dict["scope"], "access_token": source_dict["access_token"], "refresh_token": source_dict.get("refresh_token"), "token_type": source_dict.get("token_type"), "expires_at_seconds": int(time.time() + expires_in), "resource_server": source_dict["resource_server"], }
def test_text_response_repr_and_str_contain_raw_data(): expect_text = """pu-erh is a distinctive aged tea primarily produced in Yunnan depending on the tea used and how it is aged, it can be bright, floral, and fruity or it can take on mushroomy, fermented, and malty notes """ raw = _response(expect_text, encoding="utf-8", headers={"Content-Type": "text/plain"}) res = GlobusHTTPResponse(raw, client=mock.Mock()) assert expect_text in repr(res) assert expect_text in str(res)
def introspect_response() -> Callable[[], GlobusHTTPResponse]: now = time() return Mock(return_value=GlobusHTTPResponse( resp({ "username": mock_username(), "dependent_tokens_cache_id": "CACHE_ID", "token_type": "Bearer", "client_id": mock_client_id(), "scope": mock_scope(), "active": True, "nbf": now - 300, "name": mock_username(), "aud": [ "e6c75d97-532a-4c88-b031-8584a319fa3e", "952d2aa2-aa0c-4d6e-ba1a-9d5fb131ec93", "action_provider_tools_automated_tests", ], "identity_set": [ "ae2a1750-d274-11e5-b867-e74762c29f57", "6e259134-032a-11e6-a68a-537f3952f25a", "4984bc70-c0b7-11e5-9076-8b4826e7e700", "ae2a64c6-d274-11e5-b868-2bbfe4b1a2b7", "ca73e829-715f-4522-9dec-a507fe57a661", "14bf3755-6267-42f2-9e9c-ad324de4a1fb", mock_effective_identity(), ], "sub": mock_effective_identity(), "iss": "https://auth.globus.org", "exp": now + 3600, "iat": now - 300, "email": "*****@*****.**", })))
def simulate_get(self, *args, **params): """ Simulates a paginated response from a Globus API get supporting limit, offset, and has next page """ offset = params.get("offset", 0) limit = params["limit"] data = {} # dict that will be treated as the json data of a response data["offset"] = offset data["limit"] = limit # fill data field data["DATA"] = [] for i in range(offset, min(self.n, offset + limit)): data["DATA"].append({"value": i}) # fill has_next_page field data["has_next_page"] = (offset + limit) < self.n # make the simulated response response = requests.Response() response._content = six.b(json.dumps(data)) response.headers["Content-Type"] = "application/json" return IterableTransferResponse(GlobusHTTPResponse(response, mock.Mock()))
def make_response( activated=True, expires_in=0, auto_activation_supported=True, oauth_server=None, DATA=None, ): """ Helper for making ActivationRequirementsResponses with known fields """ DATA = DATA or [] data = { "activated": activated, "expires_in": expires_in, "oauth_server": oauth_server, "DATA": DATA, "auto_activation_supported": auto_activation_supported, } response = requests.Response() response.headers["Content-Type"] = "application/json" response._content = json.dumps(data).encode("utf-8") return ActivationRequirementsResponse( GlobusHTTPResponse(response, client=mock.Mock()))
def __init__(self, *args, **kwargs): GlobusHTTPResponse.__init__(self, *args, **kwargs) self._init_rs_dict() self._init_scopes_getter()
def test_value_error_indexing_on_non_json_data(): r = _response(b"foo: bar, baz: buzz") res = GlobusHTTPResponse(r, client=mock.Mock()) with pytest.raises(ValueError): res["foo"]
def _mk_json_response(data): json_response = _response(data) return _TestResponse(data, GlobusHTTPResponse(json_response, client=mock.Mock()))
def text_http_response(): text_data = "text data" text_response = requests.Response() text_response._content = six.b(text_data) text_response.headers["Content-Type"] = "text/plain" return _TestResponse(text_data, GlobusHTTPResponse(text_response))
def malformed_http_response(): malformed_response = requests.Response() malformed_response._content = six.b("{") malformed_response.headers["Content-Type"] = "application/json" return _TestResponse("{", GlobusHTTPResponse(malformed_response))
def http_no_content_type_response(): res = requests.Response() assert "Content-Type" not in res.headers return _TestResponse(None, GlobusHTTPResponse(res))
def json_http_response(): json_data = {"label1": "value1", "label2": "value2"} json_response = requests.Response() json_response._content = six.b(json.dumps(json_data)) json_response.headers["Content-Type"] = "application/json" return _TestResponse(json_data, GlobusHTTPResponse(json_response))
def request( self, method: str, path: str, *, query_params: Optional[Dict[str, Any]] = None, data: DataParamType = None, headers: Optional[Dict[str, str]] = None, encoding: Optional[str] = None, allow_redirects: bool = True, stream: bool = False, ) -> GlobusHTTPResponse: """ Send an HTTP request :param method: HTTP request method, as an all caps string :type method: str :param path: Path for the request, with or without leading slash :type path: str :param query_params: Parameters to be encoded as a query string :type query_params: dict, optional :param headers: HTTP headers to add to the request :type headers: dict :param data: Data to send as the request body. May pass through encoding. :type data: dict or str :param encoding: A way to encode request data. "json", "form", and "text" are all valid values. Custom encodings can be used only if they are registered with the transport. By default, strings get "text" behavior and all other objects get "json". :type encoding: str :param allow_redirects: Follow Location headers on redirect response automatically. Defaults to ``True`` :type allow_redirects: bool :param stream: Do not immediately download the response content. Defaults to ``False`` :type stream: bool :return: :class:`GlobusHTTPResponse \ <globus_sdk.response.GlobusHTTPResponse>` object :raises GlobusAPIError: a `GlobusAPIError` will be raised if the response to the request is received and has a status code in the 4xx or 5xx categories """ # prepare data... # copy headers if present rheaders = {**headers} if headers else {} # if a client is asked to make a request against a full URL, not just the path # component, then do not resolve the path, simply pass it through as the URL if path.startswith("https://") or path.startswith("http://"): url = path else: url = utils.slash_join(self.base_url, urllib.parse.quote(path)) # make the request log.debug("request will hit URL: %s", url) r = self.transport.request( method=method, url=url, data=data.data if isinstance(data, utils.PayloadWrapper) else data, query_params=query_params, headers=rheaders, encoding=encoding, authorizer=self.authorizer, allow_redirects=allow_redirects, stream=stream, ) log.debug("request made to URL: %s", r.url) if 200 <= r.status_code < 400: log.debug(f"request completed with response code: {r.status_code}") return GlobusHTTPResponse(r, self) log.debug( f"request completed with (error) response code: {r.status_code}") raise self.error_class(r)
def http_no_content_type_response(): res = _response() assert "Content-Type" not in res.headers return _TestResponse(None, GlobusHTTPResponse(res, client=mock.Mock()))
def test_client_required_with_requests_response(): r = _response({"foo": 1}) GlobusHTTPResponse(r, client=mock.Mock()) # ok with pytest.raises(ValueError): GlobusHTTPResponse(r) # not ok
def malformed_http_response(): malformed_response = _response( b"{", headers={"Content-Type": "application/json"}) return _TestResponse( "{", GlobusHTTPResponse(malformed_response, client=mock.Mock()))