def test_http_logger_operation_level(http_request, http_response):
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy()
kwargs = {'logger': logger}
universal_request = http_request('GET', 'http://localhost/')
http_response = create_http_response(http_response, universal_request,
None)
http_response.status_code = 202
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
# Basics
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 2
messages_request = mock_handler.messages[0].message.split("\n")
messages_response = mock_handler.messages[1].message.split("\n")
assert messages_request[0] == "Request URL: 'http://localhost/'"
assert messages_request[1] == "Request method: 'GET'"
assert messages_request[2] == 'Request headers:'
assert messages_request[3] == 'No body was attached to the request'
assert messages_response[0] == 'Response status: 202'
assert messages_response[1] == 'Response headers:'
mock_handler.reset()
# Let's make this request a failure, retried twice
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 4
messages_request1 = mock_handler.messages[0].message.split("\n")
messages_response1 = mock_handler.messages[1].message.split("\n")
messages_request2 = mock_handler.messages[2].message.split("\n")
messages_response2 = mock_handler.messages[3].message.split("\n")
assert messages_request1[0] == "Request URL: 'http://localhost/'"
assert messages_request1[1] == "Request method: 'GET'"
assert messages_request1[2] == 'Request headers:'
assert messages_request1[3] == 'No body was attached to the request'
assert messages_response1[0] == 'Response status: 202'
assert messages_response1[1] == 'Response headers:'
assert messages_request2[0] == "Request URL: 'http://localhost/'"
assert messages_request2[1] == "Request method: 'GET'"
assert messages_request2[2] == 'Request headers:'
assert messages_request2[3] == 'No body was attached to the request'
assert messages_response2[0] == 'Response status: 202'
assert messages_response2[1] == 'Response headers:'
mock_handler.reset()
async def prepare_requests(req):
context = PipelineContext(None, **pipeline_options)
pipeline_request = PipelineRequest(req, context)
for policy in policies:
await _await_result(policy.on_request, pipeline_request)
def _make_request(self):
return PipelineRequest(
HttpRequest("CredentialWrapper", "https://fakeurl"),
PipelineContext(None))
def test_http_logger():
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy(logger=logger)
universal_request = HttpRequest('GET', 'http://127.0.0.1/')
http_response = HttpResponse(universal_request, None)
http_response.status_code = 202
request = PipelineRequest(universal_request, PipelineContext(None))
# Basics
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 6
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[
3].message == 'No body was attached to the request'
assert mock_handler.messages[4].message == 'Response status: 202'
assert mock_handler.messages[5].message == 'Response headers:'
mock_handler.reset()
# Let's make this request a failure, retried twice
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 12
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[
3].message == 'No body was attached to the request'
assert mock_handler.messages[4].message == 'Response status: 202'
assert mock_handler.messages[5].message == 'Response headers:'
assert mock_handler.messages[
6].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[7].message == "Request method: 'GET'"
assert mock_handler.messages[8].message == 'Request headers:'
assert mock_handler.messages[
9].message == 'No body was attached to the request'
assert mock_handler.messages[10].message == 'Response status: 202'
assert mock_handler.messages[11].message == 'Response headers:'
mock_handler.reset()
# Headers and query parameters
policy.allowed_query_params = ['country']
universal_request.headers = {
"Accept": "Caramel",
"Hate": "Chocolat",
}
http_response.headers = {
"Content-Type": "Caramel",
"HateToo": "Chocolat",
}
universal_request.url = "http://127.0.0.1/?country=france&city=aix"
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 10
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/?country=france&city=REDACTED'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == "Request headers:"
# Dict not ordered in Python, exact logging order doesn't matter
assert set([
mock_handler.messages[3].message, mock_handler.messages[4].message
]) == set([" 'Accept': 'Caramel'", " 'Hate': 'REDACTED'"])
assert mock_handler.messages[
5].message == 'No body was attached to the request'
assert mock_handler.messages[6].message == "Response status: 202"
assert mock_handler.messages[7].message == "Response headers:"
# Dict not ordered in Python, exact logging order doesn't matter
assert set([
mock_handler.messages[8].message, mock_handler.messages[9].message
]) == set([" 'Content-Type': 'Caramel'", " 'HateToo': 'REDACTED'"])
mock_handler.reset()
def test_distributed_tracing_policy_with_user_agent():
"""Test policy working with user agent."""
with ContextHelper(environ={"AZURE_HTTP_USER_AGENT": "mytools"}):
exporter = MockExporter()
trace = tracer_module.Tracer(sampler=AlwaysOnSampler(), exporter=exporter)
with trace.span("parent"):
policy = DistributedTracingPolicy()
request = HttpRequest("GET", "http://127.0.0.1")
request.headers["x-ms-client-request-id"] = "some client request id"
pipeline_request = PipelineRequest(request, PipelineContext(None))
user_agent = UserAgentPolicy()
user_agent.on_request(pipeline_request)
policy.on_request(pipeline_request)
response = HttpResponse(request, None)
response.headers = request.headers
response.status_code = 202
response.headers["x-ms-request-id"] = "some request id"
pipeline_response = PipelineResponse(request, response, PipelineContext(None))
ctx = trace.span_context
header = trace.propagator.to_headers(ctx)
assert request.headers.get("traceparent") == header.get("traceparent")
policy.on_response(pipeline_request, pipeline_response)
time.sleep(0.001)
policy.on_request(pipeline_request)
try:
raise ValueError("Transport trouble")
except:
policy.on_exception(pipeline_request)
user_agent.on_response(pipeline_request, pipeline_response)
trace.finish()
exporter.build_tree()
parent = exporter.root
network_span = parent.children[0]
assert network_span.span_data.name == "/"
assert network_span.span_data.attributes.get("http.method") == "GET"
assert network_span.span_data.attributes.get("component") == "http"
assert network_span.span_data.attributes.get("http.url") == "http://127.0.0.1"
assert network_span.span_data.attributes.get("http.user_agent").endswith("mytools")
assert network_span.span_data.attributes.get("x-ms-request-id") == "some request id"
assert network_span.span_data.attributes.get("x-ms-client-request-id") == "some client request id"
assert network_span.span_data.attributes.get("http.status_code") == 202
network_span = parent.children[1]
assert network_span.span_data.name == "/"
assert network_span.span_data.attributes.get("http.method") == "GET"
assert network_span.span_data.attributes.get("component") == "http"
assert network_span.span_data.attributes.get("http.url") == "http://127.0.0.1"
assert network_span.span_data.attributes.get("http.user_agent").endswith("mytools")
assert network_span.span_data.attributes.get("x-ms-client-request-id") == "some client request id"
assert network_span.span_data.attributes.get("x-ms-request-id") is None
assert network_span.span_data.attributes.get("http.status_code") == 504
# Exception should propagate status for Opencensus
assert network_span.span_data.status.message == 'Transport trouble'
def test_no_log(mock_http_logger):
universal_request = HttpRequest('GET', 'http://127.0.0.1/')
request = PipelineRequest(universal_request, PipelineContext(None))
http_logger = NetworkTraceLoggingPolicy()
response = PipelineResponse(request, HttpResponse(universal_request, None),
request.context)
# By default, no log handler for HTTP
http_logger.on_request(request)
mock_http_logger.debug.assert_not_called()
http_logger.on_response(request, response)
mock_http_logger.debug.assert_not_called()
mock_http_logger.reset_mock()
# I can enable it per request
request.context.options['logging_enable'] = True
http_logger.on_request(request)
assert mock_http_logger.debug.call_count >= 1
mock_http_logger.reset_mock()
request.context.options['logging_enable'] = True
http_logger.on_response(request, response)
assert mock_http_logger.debug.call_count >= 1
mock_http_logger.reset_mock()
# I can enable it per request (bool value should be honored)
request.context.options['logging_enable'] = False
http_logger.on_request(request)
mock_http_logger.debug.assert_not_called()
request.context.options['logging_enable'] = False
http_logger.on_response(request, response)
mock_http_logger.debug.assert_not_called()
mock_http_logger.reset_mock()
# I can enable it globally
request.context.options = {}
http_logger.enable_http_logger = True
http_logger.on_request(request)
assert mock_http_logger.debug.call_count >= 1
http_logger.on_response(request, response)
assert mock_http_logger.debug.call_count >= 1
mock_http_logger.reset_mock()
# I can enable it globally and override it locally
http_logger.enable_http_logger = True
request.context.options['logging_enable'] = False
http_logger.on_request(request)
mock_http_logger.debug.assert_not_called()
response.context['logging_enable'] = False
http_logger.on_response(request, response)
mock_http_logger.debug.assert_not_called()
mock_http_logger.reset_mock()
# Let's make this request a failure, retried twice
request.context.options['logging_enable'] = True
http_logger.on_request(request)
http_logger.on_response(request, response)
first_count = mock_http_logger.debug.call_count
assert first_count >= 1
http_logger.on_request(request)
http_logger.on_response(request, response)
second_count = mock_http_logger.debug.call_count
assert second_count == first_count * 2
def test_http_logger_operation_level():
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy()
kwargs = {'logger': logger}
universal_request = HttpRequest('GET', 'http://127.0.0.1/')
http_response = HttpResponse(universal_request, None)
http_response.status_code = 202
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
# Basics
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 6
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[
3].message == 'No body was attached to the request'
assert mock_handler.messages[4].message == 'Response status: 202'
assert mock_handler.messages[5].message == 'Response headers:'
mock_handler.reset()
# Let's make this request a failure, retried twice
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 12
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[
3].message == 'No body was attached to the request'
assert mock_handler.messages[4].message == 'Response status: 202'
assert mock_handler.messages[5].message == 'Response headers:'
assert mock_handler.messages[
6].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[7].message == "Request method: 'GET'"
assert mock_handler.messages[8].message == 'Request headers:'
assert mock_handler.messages[
9].message == 'No body was attached to the request'
assert mock_handler.messages[10].message == 'Response status: 202'
assert mock_handler.messages[11].message == 'Response headers:'
mock_handler.reset()
def _build_next_request(initial_request, method, url):
request = HttpRequest(method, url)
context = PipelineContext(initial_request.context.transport,
**initial_request.context.options)
return PipelineRequest(request, context)
def test_raw_deserializer():
raw_deserializer = ContentDecodePolicy()
def build_response(body, content_type=None):
class MockResponse(HttpResponse):
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(None, MockResponse(body, content_type),
PipelineContext(None, stream=False))
response = build_response(b"<groot/>", content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result.tag == "groot"
# The basic deserializer works with unicode XML
response = build_response(u'<groot language="français"/>'.encode('utf-8'),
content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result.attrib["language"] == u"français"
# Catch some weird situation where content_type is XML, but content is JSON
response = build_response(b'{"ugly": true}',
content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["ugly"] is True
# Be sure I catch the correct exception if it's neither XML nor JSON
response = build_response(b'gibberish', content_type="application/xml")
with pytest.raises(DecodeError) as err:
raw_deserializer.on_response(None, response)
assert err.value.response is response.http_response
response = build_response(b'{{gibberish}}', content_type="application/xml")
with pytest.raises(DecodeError) as err:
raw_deserializer.on_response(None, response)
assert err.value.response is response.http_response
# Simple JSON
response = build_response(b'{"success": true}',
content_type="application/json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with complex content_type
response = build_response(
b'{"success": true}',
content_type="application/vnd.microsoft.appconfig.kv.v1+json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with complex content_type, v2
response = build_response(
b'{"success": true}',
content_type="text/vnd.microsoft.appconfig.kv.v1+json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# For compat, if no content-type, decode JSON
response = build_response(b'"data"')
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result == "data"
# Try with a mock of requests
req_response = requests.Response()
req_response.headers["content-type"] = "application/json"
req_response._content = b'{"success": true}'
req_response._content_consumed = True
response = PipelineResponse(None,
RequestsTransportResponse(None, req_response),
PipelineContext(None, stream=False))
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
def test_raw_deserializer():
raw_deserializer = ContentDecodePolicy()
context = PipelineContext(None, stream=False)
universal_request = HttpRequest('GET', 'http://localhost/')
request = PipelineRequest(universal_request, context)
def build_response(body, content_type=None):
class MockResponse(HttpResponse):
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)
response = build_response(b"<groot/>", content_type="application/xml")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result.tag == "groot"
response = build_response(b"\xef\xbb\xbf<utf8groot/>", content_type="application/xml")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result.tag == "utf8groot"
# The basic deserializer works with unicode XML
response = build_response(u'<groot language="français"/>'.encode('utf-8'), content_type="application/xml")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result.attrib["language"] == u"français"
# Catch some weird situation where content_type is XML, but content is JSON
response = build_response(b'{"ugly": true}', content_type="application/xml")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result["ugly"] is True
# Be sure I catch the correct exception if it's neither XML nor JSON
response = build_response(b'gibberish', content_type="application/xml")
with pytest.raises(DecodeError) as err:
raw_deserializer.on_response(request, response)
assert err.value.response is response.http_response
response = build_response(b'{{gibberish}}', content_type="application/xml")
with pytest.raises(DecodeError) as err:
raw_deserializer.on_response(request, response)
assert err.value.response is response.http_response
# Simple JSON
response = build_response(b'{"success": true}', content_type="application/json")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with BOM
response = build_response(b'\xef\xbb\xbf{"success": true}', content_type="application/json")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with complex content_type
response = build_response(b'{"success": true}', content_type="application/vnd.microsoft.appconfig.kv.v1+json")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# Simple JSON with complex content_type, v2
response = build_response(b'{"success": true}', content_type="text/vnd.microsoft.appconfig.kv.v1+json")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# For compat, if no content-type, decode JSON
response = build_response(b'"data"')
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result == "data"
# Let text/plain let through
response = build_response(b'I am groot', content_type="text/plain")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result == "I am groot"
# Let text/plain let through + BOM
response = build_response(b'\xef\xbb\xbfI am groot', content_type="text/plain")
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result == "I am groot"
# Try with a mock of requests
req_response = requests.Response()
req_response.headers["content-type"] = "application/json"
req_response._content = b'{"success": true}'
req_response._content_consumed = True
response = PipelineResponse(None, RequestsTransportResponse(None, req_response), PipelineContext(None, stream=False))
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# I can enable it per request
request.context.options['response_encoding'] = 'utf-8'
response = build_response(b'\xc3\xa9', content_type="text/plain")
raw_deserializer.on_request(request)
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result == u"é"
assert response.context["response_encoding"] == "utf-8"
del request.context['response_encoding']
# I can enable it globally
raw_deserializer = ContentDecodePolicy(response_encoding="utf-8")
response = build_response(b'\xc3\xa9', content_type="text/plain")
raw_deserializer.on_request(request)
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result == u"é"
assert response.context["response_encoding"] == "utf-8"
del request.context['response_encoding']
# Per request is more important
request.context.options['response_encoding'] = 'utf-8-sig'
response = build_response(b'\xc3\xa9', content_type="text/plain")
raw_deserializer.on_request(request)
raw_deserializer.on_response(request, response)
result = response.context["deserialized_data"]
assert result == u"é"
assert response.context["response_encoding"] == "utf-8-sig"
del request.context['response_encoding']
def _make_request(self):
return PipelineRequest(
HttpRequest("AzureIdentityCredentialAdapter", "https://fakeurl"),
PipelineContext(None))
def test_distributed_tracing_policy_with_user_agent(http_request,
http_response):
"""Test policy working with user agent."""
settings.tracing_implementation.set_value(FakeSpan)
with mock.patch.dict('os.environ', {"AZURE_HTTP_USER_AGENT": "mytools"}):
with FakeSpan(name="parent") as root_span:
policy = DistributedTracingPolicy()
request = http_request("GET", "http://localhost")
request.headers[
"x-ms-client-request-id"] = "some client request id"
pipeline_request = PipelineRequest(request, PipelineContext(None))
user_agent = UserAgentPolicy()
user_agent.on_request(pipeline_request)
policy.on_request(pipeline_request)
response = create_http_response(http_response, request, None)
response.headers = request.headers
response.status_code = 202
response.headers["x-ms-request-id"] = "some request id"
pipeline_response = PipelineResponse(request, response,
PipelineContext(None))
assert request.headers.get("traceparent") == '123456789'
policy.on_response(pipeline_request, pipeline_response)
time.sleep(0.001)
policy.on_request(pipeline_request)
try:
raise ValueError("Transport trouble")
except:
policy.on_exception(pipeline_request)
user_agent.on_response(pipeline_request, pipeline_response)
network_span = root_span.children[0]
assert network_span.name == "/"
assert network_span.attributes.get("http.method") == "GET"
assert network_span.attributes.get("component") == "http"
assert network_span.attributes.get("http.url") == "http://localhost"
assert network_span.attributes.get("http.user_agent").endswith(
"mytools")
assert network_span.attributes.get(
"x-ms-request-id") == "some request id"
assert network_span.attributes.get(
"x-ms-client-request-id") == "some client request id"
assert network_span.attributes.get("http.status_code") == 202
network_span = root_span.children[1]
assert network_span.name == "/"
assert network_span.attributes.get("http.method") == "GET"
assert network_span.attributes.get("component") == "http"
assert network_span.attributes.get("http.url") == "http://localhost"
assert network_span.attributes.get("http.user_agent").endswith(
"mytools")
assert network_span.attributes.get(
"x-ms-client-request-id") == "some client request id"
assert network_span.attributes.get("x-ms-request-id") is None
assert network_span.attributes.get("http.status_code") == 504
# Exception should propagate status for Opencensus
assert network_span.status == 'Transport trouble'
def _make_request():
"""Make mocked request to get token."""
return PipelineRequest(HttpRequest("CredentialWrapper", "https://fakeurl"),
PipelineContext(None))
def test_distributed_tracing_policy_solo(should_set_sdk_context):
"""Test policy with no other policy and happy path"""
with ContextHelper():
exporter = MockExporter()
trace = tracer_module.Tracer(sampler=AlwaysOnSampler(),
exporter=exporter)
with trace.span("parent"):
if should_set_sdk_context:
tracing_context.current_span.set(
OpenCensusSpan(trace.current_span()))
policy = DistributedTracingPolicy()
request = HttpRequest("GET", "http://127.0.0.1/temp?query=query")
request.headers[
"x-ms-client-request-id"] = "some client request id"
pipeline_request = PipelineRequest(request, PipelineContext(None))
policy.on_request(pipeline_request)
response = HttpResponse(request, None)
response.headers = request.headers
response.status_code = 202
response.headers["x-ms-request-id"] = "some request id"
ctx = trace.span_context
header = trace.propagator.to_headers(ctx)
assert request.headers.get("traceparent") == header.get(
"traceparent")
policy.on_response(
pipeline_request,
PipelineResponse(request, response, PipelineContext(None)))
time.sleep(0.001)
policy.on_request(pipeline_request)
policy.on_exception(pipeline_request)
trace.finish()
exporter.build_tree()
parent = exporter.root
network_span = parent.children[0]
assert network_span.span_data.name == "/temp"
assert network_span.span_data.attributes.get("http.method") == "GET"
assert network_span.span_data.attributes.get("component") == "http"
assert network_span.span_data.attributes.get(
"http.url") == "http://127.0.0.1/temp?query=query"
assert network_span.span_data.attributes.get("http.user_agent") is None
assert network_span.span_data.attributes.get(
"x-ms-request-id") == "some request id"
assert network_span.span_data.attributes.get(
"x-ms-client-request-id") == "some client request id"
assert network_span.span_data.attributes.get("http.status_code") == 202
network_span = parent.children[1]
assert network_span.span_data.name == "/temp"
assert network_span.span_data.attributes.get("http.method") == "GET"
assert network_span.span_data.attributes.get("component") == "http"
assert network_span.span_data.attributes.get(
"http.url") == "http://127.0.0.1/temp?query=query"
assert network_span.span_data.attributes.get(
"x-ms-client-request-id") == "some client request id"
assert network_span.span_data.attributes.get("http.user_agent") is None
assert network_span.span_data.attributes.get("x-ms-request-id") == None
assert network_span.span_data.attributes.get("http.status_code") == 504
def test_raw_deserializer():
raw_deserializer = ContentDecodePolicy()
def build_response(body, content_type=None):
class MockResponse(HttpResponse):
def __init__(self, body, content_type):
super(MockResponse, self).__init__(None, None)
self._body = body
self.content_type = None
if content_type:
self.content_type = [content_type]
def body(self):
return self._body
return PipelineResponse(None, MockResponse(body, content_type),
PipelineContext(None, stream=False))
response = build_response(b"<groot/>", content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result.tag == "groot"
# Catch some weird situation where content_type is XML, but content is JSON
response = build_response(b'{"ugly": true}',
content_type="application/xml")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["ugly"] is True
# Be sure I catch the correct exception if it's neither XML nor JSON
with pytest.raises(DecodeError):
response = build_response(b'gibberish', content_type="application/xml")
raw_deserializer.on_response(
None,
response,
)
with pytest.raises(DecodeError):
response = build_response(b'{{gibberish}}',
content_type="application/xml")
raw_deserializer.on_response(None, response)
# Simple JSON
response = build_response(b'{"success": true}',
content_type="application/json")
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
# For compat, if no content-type, decode JSON
response = build_response(b'"data"')
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result == "data"
# Try with a mock of requests
req_response = requests.Response()
req_response.headers["content-type"] = "application/json"
req_response._content = b'{"success": true}'
req_response._content_consumed = True
response = PipelineResponse(None,
RequestsTransportResponse(None, req_response),
PipelineContext(None, stream=False))
raw_deserializer.on_response(None, response)
result = response.context["deserialized_data"]
assert result["success"] is True
def prepare_requests(req):
context = PipelineContext(None)
pipeline_request = PipelineRequest(req, context)
for policy in policies:
_await_result(policy.on_request, pipeline_request)
