async def test_send_data(port, http_request): async with TrioRequestsTransport() as transport: req = http_request('PUT', 'http://localhost:{}/basic/anything'.format(port), data=b"azerty") response = await transport.send(req) if is_rest(http_request): assert is_rest(response) assert json.loads(response.text())['data'] == "azerty"
def test_repr(http_response): res = _create_aiohttp_response(http_response, b'\xef\xbb\xbf56', {}) res.content_type = "text/plain" class_name = "AsyncHttpResponse" if is_rest( http_response) else "AioHttpTransportResponse" assert repr(res) == f"<{class_name}: 200 OK, Content-Type: text/plain>"
def test_repr(http_response): res = _create_requests_response(http_response, b'\xef\xbb\xbf56', {'Content-Type': 'text/plain'}) class_name = "HttpResponse" if is_rest( http_response) else "RequestsTransportResponse" assert repr(res) == "<{}: 200 OK, Content-Type: text/plain>".format( class_name)
def on_request(self, request): assert is_rest(request.http_request) assert request.http_request.content == '{"hello": "world"}' # modify header to know we entered this callback request.http_request.headers = { "x-ms-date": "Thu, 14 Jun 2018 16:46:54 GMT", "Authorization": "SharedKey account:G4jjBXA7LI/RnWKIOQ8i9xH4p76pAQ+4Fs4R1VxasaE=", "Content-Length": "0", }
def create_transport_response(http_response, *args, **kwargs): # this creates transport-specific responses, # like requests responses / aiohttp responses if is_rest(http_response): block_size = args[2] if len(args) > 2 else None return http_response(request=args[0], internal_response=args[1], block_size=block_size, **kwargs) return http_response(*args, **kwargs)
async def test_aiohttp_response_text(http_response): for encoding in ["utf-8", "utf-8-sig", None]: res = _create_aiohttp_response(http_response, b'\xef\xbb\xbf56', {'Content-Type': 'text/plain'}) if is_rest(http_response): await res.read() assert res.text(encoding) == '56', "Encoding {} didn't work".format( encoding)
def mock_send(http_request, http_response, method, status, headers=None, body=RESPONSE_BODY): if headers is None: headers = {} response = Response() response._content_consumed = True response._content = json.dumps(body).encode('ascii') if body is not None else None response.request = Request() response.request.method = method response.request.url = RESOURCE_URL response.request.headers = { 'x-ms-client-request-id': '67f4dd4e-6262-45e1-8bed-5c45cf23b6d9' } response.status_code = status response.headers = headers response.headers.update({"content-type": "application/json; charset=utf8"}) response.reason = "OK" if is_rest(http_request): request = http_request( response.request.method, response.request.url, headers=response.request.headers, content=body, ) else: request = CLIENT._request( response.request.method, response.request.url, None, # params response.request.headers, body, None, # form_content None # stream_content ) response = create_transport_response(http_response, request, response) if is_rest(http_response): response.body() return PipelineResponse( request, response, None # context )
def on_request(self, request): assert is_rest(request.http_request) # don't want to deal with content in serialize, so let's first just remove it request.http_request.data = None expected = ( b'DELETE http://localhost:5000/container0/blob0 HTTP/1.1\r\n' b'x-ms-date: Thu, 14 Jun 2018 16:46:54 GMT\r\n' b'Authorization: SharedKey account:G4jjBXA7LI/RnWKIOQ8i9xH4p76pAQ+4Fs4R1VxasaE=\r\n' # fake key suppressed in credscan b'Content-Length: 0\r\n' b'\r\n') assert request.http_request.serialize() == expected raise ValueError("Passed through the policies!")
async def test_async_gen_data(port, http_request): class AsyncGen: def __init__(self): self._range = iter([b"azerty"]) def __aiter__(self): return self async def __anext__(self): try: return next(self._range) except StopIteration: raise StopAsyncIteration async with TrioRequestsTransport() as transport: req = http_request('GET', 'http://localhost:{}/basic/anything'.format(port), data=AsyncGen()) response = await transport.send(req) if is_rest(http_request): assert is_rest(response) assert json.loads(response.text())['data'] == "azerty"
def mock_update(http_request, http_response, url, headers=None): response = Response() response._content_consumed = True response.request = mock.create_autospec(Request) response.request.method = 'GET' response.headers = headers or {} response.headers.update({"content-type": "application/json; charset=utf8"}) response.reason = "OK" if url == ASYNC_URL: response.request.url = url response.status_code = POLLING_STATUS response._content = ASYNC_BODY.encode('ascii') response.randomFieldFromPollAsyncOpHeader = None elif url == LOCATION_URL: response.request.url = url response.status_code = POLLING_STATUS response._content = LOCATION_BODY.encode('ascii') response.randomFieldFromPollLocationHeader = None elif url == ERROR: raise BadEndpointError("boom") elif url == RESOURCE_URL: response.request.url = url response.status_code = POLLING_STATUS response._content = RESOURCE_BODY.encode('ascii') else: raise Exception('URL does not match') request = http_request( response.request.method, response.request.url, ) response = create_transport_response(http_response, request, response) if is_rest(http_response): response.body() return PipelineResponse( request, response, None # context )
def create_http_response(http_response, *args, **kwargs): # since the actual http_response object is # an ABC for our new responses, it's a little more # complicated creating a pure http response. # here, we use the HttpResponsImpl, but we still have to pass # more things to the init, so making a separate operation if is_rest(http_response): block_size = args[2] if len(args) > 2 else None return http_response(request=args[0], internal_response=args[1], block_size=block_size, status_code=kwargs.pop("status_code", 200), reason=kwargs.pop("reason", "OK"), content_type=kwargs.pop("content_type", "application/json"), headers=kwargs.pop("headers", {}), stream_download_generator=kwargs.pop( "stream_download_generator", None), **kwargs) return http_response(*args, **kwargs)
def test_http_client_response(port, http_request, http_response): # Create a core request request = http_request("GET", "http://localhost:{}".format(port)) # Fake a transport based on http.client conn = HTTPConnection("localhost", port) conn.request("GET", "/get") r1 = conn.getresponse() response = create_transport_response(http_response, request, r1) if is_rest(http_response): response.read() # Don't assume too much in those assert, since we reach a real server assert response.internal_response is r1 assert response.reason is not None assert isinstance(response.status_code, int) assert len(response.headers.keys()) != 0 assert len(response.text()) != 0 assert "content-type" in response.headers assert "Content-Type" in response.headers
def build_response(body, content_type=None): if is_rest(http_response): class MockResponse(http_response): def __init__(self, body, content_type): super(MockResponse, self).__init__( request=None, internal_response=None, status_code=400, reason="Bad Request", content_type="application/json", headers={}, stream_download_generator=None, ) self._body = body self.content_type = content_type def body(self): return self._body def read(self): self._content = self._body return self.content else: class MockResponse(http_response): def __init__(self, body, content_type): super(MockResponse, self).__init__(None, None) self._body = body self.content_type = content_type def body(self): return self._body return PipelineResponse(request, MockResponse(body, content_type), context)
def callback(request): assert is_rest(request.http_request) raise ValueError("I entered the callback!")
def on_request(self, pipeline_request): request = pipeline_request.http_request assert is_rest(request) assert request.body == '{"hello": "world"}' # old request has property body request.set_text_body("change to me!") return pipeline_request
def on_request(self, request): assert is_rest(request.http_request) # first make sure this is a new request # deals with request like an old request request.http_request.set_json_body({"hello": "world"})
def on_request(self, pipeline_request): request = pipeline_request.http_request assert is_rest(request) assert request.content == 'change to me!' # new request has property content raise ValueError("I entered the policies!")