def _build_pipeline(self, **kwargs): # pylint: disable=no-self-use transport = kwargs.get('transport') policies = kwargs.get('policies') credential_policy = ServiceBusSharedKeyCredentialPolicy(self._endpoint, self._credential, "Authorization") \ if isinstance(self._credential, ServiceBusSharedKeyCredential) \ else BearerTokenCredentialPolicy(self._credential, JWT_TOKEN_SCOPE) if policies is None: # [] is a valid policy list policies = [ RequestIdPolicy(**kwargs), self._config.headers_policy, self._config.user_agent_policy, self._config.proxy_policy, ContentDecodePolicy(**kwargs), self._config.redirect_policy, self._config.retry_policy, credential_policy, self._config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if not transport: transport = RequestsTransport(**kwargs) return Pipeline(transport, policies)
def test_http_logger_with_generator_body(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(logger=logger) universal_request = http_request('GET', 'http://localhost/') mock = Mock() mock.__class__ = types.AsyncGeneratorType universal_request.body = mock http_response = create_http_response(http_response, universal_request, None) http_response.status_code = 202 request = PipelineRequest(universal_request, PipelineContext(None)) 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] == 'File upload' assert messages_response[0] == 'Response status: 202' assert messages_response[1] == 'Response headers:' mock_handler.reset()
def _create_appconfig_pipeline(self, **kwargs): transport = kwargs.get('transport') policies = kwargs.get('policies') if policies is None: # [] is a valid policy list policies = [ self._config.headers_policy, self._config.user_agent_policy, AppConfigRequestsCredentialsPolicy(self._config.credentials), SyncTokenPolicy(), self._config.retry_policy, self._config.logging_policy, # HTTP request/response log DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if not transport: transport = AsyncioRequestsTransport(**kwargs) return AsyncPipeline( transport, policies, )
def _build_pipeline(config: Configuration, transport: AsyncHttpTransport, **kwargs: "Any") -> AsyncPipeline: logging_policy = HttpLoggingPolicy(**kwargs) logging_policy.allowed_header_names.add("x-ms-keyvault-network-info") policies = [ config.headers_policy, config.user_agent_policy, config.proxy_policy, ContentDecodePolicy(), config.redirect_policy, config.retry_policy, config.authentication_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), logging_policy, ] if transport is None: from azure.core.pipeline.transport import AioHttpTransport transport = AioHttpTransport(**kwargs) return AsyncPipeline(transport, policies=policies)
def __init__( self, config=None, # type: Optional[Configuration] policies=None, # type: Optional[PolicyListType] transport=None, # type: Optional[HttpTransport] **kwargs # type: Any ): # type: (...) -> None config = config or self._create_config(**kwargs) policies = policies or [ ContentDecodePolicy(), config.user_agent_policy, config.proxy_policy, config.retry_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if not transport: transport = RequestsTransport(**kwargs) self._pipeline = Pipeline(transport=transport, policies=policies) # type: Pipeline super(AuthnClient, self).__init__(**kwargs)
def _create_pipeline(self, credential, **kwargs): credential_policy = None if credential is None: raise ValueError("Parameter 'credential' must not be None.") if hasattr(credential, "get_token"): credential_policy = AsyncBearerTokenCredentialPolicy( credential, "https://cognitiveservices.azure.com/.default") elif isinstance(credential, TextAnalyticsAPIKeyCredential): credential_policy = CognitiveServicesCredentialPolicy(credential) elif credential is not None: raise TypeError( "Unsupported credential: {}. Use an instance of TextAnalyticsAPIKeyCredential " "or a token credential from azure.identity".format( type(credential))) config = self._create_configuration(**kwargs) config.transport = kwargs.get("transport") # type: ignore if not config.transport: try: from azure.core.pipeline.transport import AioHttpTransport except ImportError: raise ImportError( "Unable to create async transport. Please check aiohttp is installed." ) config.transport = AioHttpTransport(**kwargs) policies = [ config.headers_policy, config.user_agent_policy, RequestIdPolicy(**kwargs), config.proxy_policy, AsyncRedirectPolicy(**kwargs), AsyncRetryPolicy(**kwargs), credential_policy, config.logging_policy, AsyncTextAnalyticsResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs) ] return AsyncPipeline(config.transport, policies=policies)
def __init__(self, endpoint, credential, **kwargs): http_logging_policy = HttpLoggingPolicy(**kwargs) http_logging_policy.allowed_header_names.update({ "Operation-Location", "apim-request-id", "x-envoy-upstream-service-time", "Strict-Transport-Security", "x-content-type-options", }) http_logging_policy.allowed_query_params.update({ "model-version", "showStats", "loggingOptOut", "domain", "stringIndexType", "piiCategories", "$top", "$skip", "opinionMining", }) try: endpoint = endpoint.rstrip("/") except AttributeError: raise ValueError("Parameter 'endpoint' must be a string.") self._client = _TextAnalyticsClient( endpoint=endpoint, credential=credential, api_version=kwargs.pop("api_version", DEFAULT_API_VERSION), sdk_moniker=USER_AGENT, authentication_policy=kwargs.pop( "authentication_policy", _authentication_policy(credential)), custom_hook_policy=kwargs.pop( "custom_hook_policy", TextAnalyticsResponseHookPolicy(**kwargs)), http_logging_policy=kwargs.pop("http_logging_policy", http_logging_policy), **kwargs)
def _create_appconfig_pipeline(self, credential, base_url=None, aad_mode=False, **kwargs): transport = kwargs.get("transport") policies = kwargs.get("policies") if policies is None: # [] is a valid policy list if aad_mode: scope = base_url.strip("/") + "/.default" if hasattr(credential, "get_token"): credential_policy = BearerTokenCredentialPolicy( credential, scope) else: raise TypeError( "Please provide an instance from azure-identity " "or a class that implement the 'get_token protocol") else: credential_policy = AppConfigRequestsCredentialsPolicy( credential) policies = [ self._config.headers_policy, self._config.user_agent_policy, self._config.retry_policy, self._sync_token_policy, credential_policy, self._config.logging_policy, # HTTP request/response log DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ContentDecodePolicy(**kwargs), ] if not transport: transport = RequestsTransport(**kwargs) return Pipeline(transport, policies)
def _create_pipeline(self, credential, **kwargs): # type: (Any, **Any) -> Tuple[Configuration, Pipeline] self._credential_policy = None if hasattr(credential, "get_token"): self._credential_policy = BearerTokenCredentialPolicy( credential, STORAGE_OAUTH_SCOPE ) elif isinstance(credential, SharedKeyCredentialPolicy): self._credential_policy = credential elif credential is not None: raise TypeError("Unsupported credential: {}".format(credential)) config = kwargs.get("_configuration") or create_configuration(**kwargs) if kwargs.get("_pipeline"): return config, kwargs["_pipeline"] config.transport = kwargs.get("transport") # type: ignore kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT) kwargs.setdefault("read_timeout", READ_TIMEOUT) if not config.transport: config.transport = RequestsTransport(**kwargs) policies = [ config.headers_policy, config.proxy_policy, config.user_agent_policy, StorageContentValidation(), StorageRequestHook(**kwargs), self._credential_policy, ContentDecodePolicy(response_encoding="utf-8"), RedirectPolicy(**kwargs), StorageHosts(hosts=self._hosts, **kwargs), config.retry_policy, config.logging_policy, StorageResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] return config, Pipeline(config.transport, policies=policies)
def get_http_logging_policy(**kwargs): http_logging_policy = HttpLoggingPolicy(**kwargs) http_logging_policy.allowed_header_names.update({ "Operation-Location", "Content-Encoding", "Vary", "apim-request-id", "X-RequestId", "Set-Cookie", "X-Powered-By", "Strict-Transport-Security", "x-content-type-options", }) http_logging_policy.allowed_query_params.update({ "$top", "$skip", "$maxpagesize", "ids", "statuses", "createdDateTimeUtcStart", "createdDateTimeUtcEnd", "$orderBy", }) return http_logging_policy
def test_http_logger_with_body(): 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/') universal_request.body = "testbody" http_response = HttpResponse(universal_request, None) http_response.status_code = 202 request = PipelineRequest(universal_request, PipelineContext(None)) 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 == 'A body is sent with the request' assert mock_handler.messages[4].message == 'Response status: 202' assert mock_handler.messages[5].message == 'Response headers:' mock_handler.reset()
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()
def __init__( self, endpoint: str, credential: Union["AzureKeyCredential", "AsyncTokenCredential"], **kwargs: Any ) -> None: try: endpoint = endpoint.rstrip("/") except AttributeError: raise ValueError("Parameter 'endpoint' must be a string.") self._endpoint = endpoint self._credential = credential self._api_version = kwargs.pop("api_version", None) if not self._api_version: raise ValueError("'api_version' must be specified.") if self._api_version.startswith("v"): # v2.0 released with this option self._api_version = self._api_version[1:] client_kind = kwargs.pop("client_kind") validate_api_version(self._api_version, client_kind) authentication_policy = get_authentication_policy(credential) polling_interval = kwargs.pop("polling_interval", POLLING_INTERVAL) http_logging_policy = HttpLoggingPolicy(**kwargs) http_logging_policy.allowed_header_names.update( { "Operation-Location", "Location", "x-envoy-upstream-service-time", "apim-request-id", "Strict-Transport-Security", "x-content-type-options", "ms-azure-ai-errorcode", "x-ms-cs-error-code", } ) http_logging_policy.allowed_query_params.update( { "includeTextDetails", "locale", "language", "includeKeys", "op", "pages", "readingOrder", "stringIndexType", "api-version", } ) self._client = FormRecognizer( endpoint=endpoint, credential=credential, # type: ignore api_version=self._api_version, sdk_moniker=USER_AGENT, authentication_policy=kwargs.get( "authentication_policy", authentication_policy ), http_logging_policy=kwargs.get("http_logging_policy", http_logging_policy), per_retry_policies=kwargs.get("per_retry_policies", QuotaExceededPolicy()), polling_interval=polling_interval, **kwargs ) self._deserialize = _get_deserialize(self._api_version) self._generated_models = self._client.models(self._api_version)
def __init__(self, endpoint, credential, ledger_certificate_path, **kwargs): # type: (str, Union[ConfidentialLedgerCertificateCredential, TokenCredential], str, Any) -> None client = kwargs.get("generated_client") if client: # caller provided a configured client -> nothing left to initialize self._client = client return if not endpoint: raise ValueError("Expected endpoint to be a non-empty string") if not credential: raise ValueError("Expected credential to not be None") if not isinstance(ledger_certificate_path, str): raise TypeError("ledger_certificate_path must be a string") if ledger_certificate_path == "": raise ValueError( "If not None, ledger_certificate_path must be a non-empty string" ) try: endpoint = endpoint.strip(" /") if not endpoint.startswith("https://"): self._endpoint = "https://" + endpoint else: self._endpoint = endpoint except AttributeError: raise ValueError("Confidential Ledger URL must be a string.") self.api_version = kwargs.pop("api_version", DEFAULT_VERSION) pipeline = kwargs.pop("pipeline", None) transport = kwargs.pop("transport", None) if transport is None: # Customize the transport layer to use client certificate authentication and validate # a self-signed TLS certificate. if isinstance(credential, ConfidentialLedgerCertificateCredential): kwargs["connection_cert"] = credential.certificate_path kwargs["connection_verify"] = ledger_certificate_path transport = RequestsTransport(**kwargs) http_logging_policy = HttpLoggingPolicy(**kwargs) http_logging_policy.allowed_header_names.update({ "x-ms-keyvault-network-info", "x-ms-keyvault-region", "x-ms-keyvault-service-version", }) if not isinstance(credential, ConfidentialLedgerCertificateCredential): kwargs["authentication_policy"] = kwargs.pop( "authentication_policy", BearerTokenCredentialPolicy( credential, "https://confidential-ledger.azure.com/.default", **kwargs), ) try: self._client = _ConfidentialLedgerClient( self._endpoint, api_version=self.api_version, pipeline=pipeline, transport=transport, http_logging_policy=http_logging_policy, **kwargs) except NotImplementedError: raise NotImplementedError( "This package doesn't support API version '{}'. ".format( self.api_version) + "Supported versions: 0.1-preview")
def __init__( self, *, endpoint: str, credential: Union[ConfidentialLedgerCertificateCredential, "TokenCredential"], ledger_certificate_path: str, **kwargs: Any ) -> None: client = kwargs.get("generated_client") if client: # caller provided a configured client -> nothing left to initialize self._client = client return if not endpoint: raise ValueError("Expected endpoint to be a non-empty string") if not credential: raise ValueError("Expected credential to not be None") if not isinstance(ledger_certificate_path, str): raise TypeError("ledger_certificate_path must be a string") if ledger_certificate_path == "": raise ValueError( "If not None, ledger_certificate_path must be a non-empty string" ) endpoint = endpoint.strip(" /") try: if not endpoint.startswith("https://"): self._endpoint = "https://" + endpoint else: self._endpoint = endpoint except AttributeError: raise ValueError("Confidential Ledger URL must be a string.") self.api_version = kwargs.pop("api_version", DEFAULT_VERSION) if not kwargs.get("transport", None): # Customize the transport layer to use client certificate authentication and validate # a self-signed TLS certificate. if isinstance(credential, ConfidentialLedgerCertificateCredential): # The async version of the client seems to expect a sequence of filenames. # azure/core/pipeline/transport/_aiohttp.py:163 # > ssl_ctx.load_cert_chain(*cert) kwargs["connection_cert"] = (credential.certificate_path,) kwargs["connection_verify"] = ledger_certificate_path http_logging_policy = HttpLoggingPolicy(**kwargs) http_logging_policy.allowed_header_names.update( { "x-ms-keyvault-network-info", "x-ms-keyvault-region", "x-ms-keyvault-service-version", } ) if not isinstance(credential, ConfidentialLedgerCertificateCredential): kwargs["authentication_policy"] = kwargs.pop( "authentication_policy", AsyncBearerTokenCredentialPolicy( credential, "https://confidential-ledger.azure.com/.default", **kwargs ), ) try: self._client = _ConfidentialLedgerClient( self._endpoint, api_version=self.api_version, http_logging_policy=http_logging_policy, sdk_moniker=USER_AGENT, **kwargs ) except NotImplementedError: raise NotImplementedError( "This package doesn't support API version '{}'. ".format( self.api_version ) + "Supported versions: 0.1-preview" )
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) == 5 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 == 'Response status: 202' assert mock_handler.messages[4].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) == 10 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 == 'Response status: 202' assert mock_handler.messages[4].message == 'Response headers:' 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 == 'Response status: 202' assert mock_handler.messages[4].message == 'Response headers:' mock_handler.reset()
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) == 5 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 == 'Response status: 202' assert mock_handler.messages[4].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) == 10 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 == 'Response status: 202' assert mock_handler.messages[4].message == 'Response headers:' 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 == 'Response status: 202' assert mock_handler.messages[4].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) == 9 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 == "Response status: 202" assert mock_handler.messages[6].message == "Response headers:" # Dict not ordered in Python, exact logging order doesn't matter assert set([ mock_handler.messages[7].message, mock_handler.messages[8].message ]) == set([" 'Content-Type': 'Caramel'", " 'HateToo': 'REDACTED'"]) mock_handler.reset()
def __init__( self, parsed_url, # type: Any service, # type: str credential=None, # type: Optional[Any] **kwargs # type: Any ): # type: (...) -> None self._location_mode = kwargs.get("_location_mode", LocationMode.PRIMARY) self._hosts = kwargs.get("_hosts") self.scheme = parsed_url.scheme if service not in ["blob", "queue", "file-share", "dfs", "table"]: raise ValueError("Invalid service: {}".format(service)) service_name = service.split("-")[0] account = parsed_url.netloc.split(".{}.core.".format(service_name)) if "cosmos" in parsed_url.netloc: account = parsed_url.netloc.split( ".{}.cosmos.".format(service_name)) self.account_name = account[0] if len(account) > 1 else None secondary_hostname = None self.credential = format_shared_key_credential(account, credential) if self.scheme.lower() != "https" and hasattr(self.credential, "get_token"): raise ValueError("Token credential is only supported with HTTPS.") if hasattr(self.credential, "account_name"): self.account_name = self.credential.account_name secondary_hostname = "{}-secondary.{}.{}".format( self.credential.account_name, service_name, SERVICE_HOST_BASE) if not self._hosts: if len(account) > 1: secondary_hostname = parsed_url.netloc.replace( account[0], account[0] + "-secondary") if kwargs.get("secondary_hostname"): secondary_hostname = kwargs["secondary_hostname"] primary_hostname = (parsed_url.netloc + parsed_url.path).rstrip("/") self._hosts = { LocationMode.PRIMARY: primary_hostname, LocationMode.SECONDARY: secondary_hostname, } self.require_encryption = kwargs.get("require_encryption", False) self.key_encryption_key = kwargs.get("key_encryption_key") self.key_resolver_function = kwargs.get("key_resolver_function") self._configure_credential(self.credential) kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT) kwargs.setdefault("read_timeout", READ_TIMEOUT) self._policies = [ StorageHeadersPolicy(**kwargs), ProxyPolicy(**kwargs), UserAgentPolicy(sdk_moniker=SDK_MONIKER, **kwargs), StorageContentValidation(), StorageRequestHook(**kwargs), self._credential_policy, ContentDecodePolicy(response_encoding="utf-8"), RedirectPolicy(**kwargs), StorageHosts(hosts=self._hosts, **kwargs), kwargs.get("retry_policy") or TablesRetryPolicy(**kwargs), StorageLoggingPolicy(**kwargs), StorageResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
def get_http_logging_policy(**kwargs): http_logging_policy = HttpLoggingPolicy(**kwargs) http_logging_policy.allowed_header_names.update({"MS-CV"}) return http_logging_policy