async def test_sans_io_exception():
class BrokenSender(AsyncHttpTransport):
async def send(self, request, **config):
raise ValueError("Broken")
async def open(self):
self.session = requests.Session()
async def close(self):
self.session.close()
async def __aexit__(self, exc_type, exc_value, traceback):
"""Raise any exception triggered within the runtime context."""
return self.close()
pipeline = AsyncPipeline(BrokenSender(), [SansIOHTTPPolicy()])
req = HttpRequest('GET', '/')
with pytest.raises(ValueError):
await pipeline.run(req)
class SwapExec(SansIOHTTPPolicy):
def on_exception(self, requests, **kwargs):
exc_type, exc_value, exc_traceback = sys.exc_info()
raise NotImplementedError(exc_value)
pipeline = AsyncPipeline(BrokenSender(), [SwapExec()])
with pytest.raises(NotImplementedError):
await pipeline.run(req)
async def test_bearer_policy_token_caching():
good_for_one_hour = AccessToken("token", time.time() + 3600)
expected_token = good_for_one_hour
get_token_calls = 0
async def get_token(_):
nonlocal get_token_calls
get_token_calls += 1
return expected_token
credential = Mock(get_token=get_token)
policies = [AsyncBearerTokenCredentialPolicy(credential, "scope"), Mock(send=asyncio.coroutine(lambda _: Mock()))]
pipeline = AsyncPipeline(transport=Mock, policies=policies)
await pipeline.run(HttpRequest("GET", "https://spam.eggs"))
assert get_token_calls == 1 # policy has no token at first request -> it should call get_token
await pipeline.run(HttpRequest("GET", "https://spam.eggs"))
assert get_token_calls == 1 # token is good for an hour -> policy should return it from cache
expired_token = AccessToken("token", time.time())
get_token_calls = 0
expected_token = expired_token
policies = [AsyncBearerTokenCredentialPolicy(credential, "scope"), Mock(send=asyncio.coroutine(lambda _: Mock()))]
pipeline = AsyncPipeline(transport=Mock(), policies=policies)
await pipeline.run(HttpRequest("GET", "https://spam.eggs"))
assert get_token_calls == 1
await pipeline.run(HttpRequest("GET", "https://spam.eggs"))
assert get_token_calls == 2 # token expired -> policy should call get_token
async def test_bearer_policy_calls_sansio_methods():
"""AsyncBearerTokenCredentialPolicy should call SansIOHttpPolicy methods as does _SansIOAsyncHTTPPolicyRunner"""
class TestPolicy(AsyncBearerTokenCredentialPolicy):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.on_exception = Mock(return_value=False)
self.on_request = Mock()
self.on_response = Mock()
async def send(self, request):
self.request = request
self.response = await super().send(request)
return self.response
credential = Mock(get_token=Mock(return_value=get_completed_future(
AccessToken("***",
int(time.time()) + 3600))))
policy = TestPolicy(credential, "scope")
transport = Mock(send=Mock(
return_value=get_completed_future(Mock(status_code=200))))
pipeline = AsyncPipeline(transport=transport, policies=[policy])
await pipeline.run(HttpRequest("GET", "https://localhost"))
policy.on_request.assert_called_once_with(policy.request)
policy.on_response.assert_called_once_with(policy.request, policy.response)
# the policy should call on_exception when next.send() raises
class TestException(Exception):
pass
# during the first send...
transport = Mock(send=Mock(side_effect=TestException))
policy = TestPolicy(credential, "scope")
pipeline = AsyncPipeline(transport=transport, policies=[policy])
with pytest.raises(TestException):
await pipeline.run(HttpRequest("GET", "https://localhost"))
policy.on_exception.assert_called_once_with(policy.request)
# ...or the second
async def fake_send(*args, **kwargs):
if fake_send.calls == 0:
fake_send.calls = 1
return Mock(
status_code=401,
headers={"WWW-Authenticate": 'Basic realm="localhost"'})
raise TestException()
fake_send.calls = 0
policy = TestPolicy(credential, "scope")
policy.on_challenge = Mock(return_value=get_completed_future(True))
transport = Mock(send=Mock(wraps=fake_send))
pipeline = AsyncPipeline(transport=transport, policies=[policy])
with pytest.raises(TestException):
await pipeline.run(HttpRequest("GET", "https://localhost"))
assert transport.send.call_count == 2
policy.on_challenge.assert_called_once()
policy.on_exception.assert_called_once_with(policy.request)
async def test_response_streaming_error_behavior():
# Test to reproduce https://github.com/Azure/azure-sdk-for-python/issues/16723
block_size = 103
total_response_size = 500
req_response = requests.Response()
req_request = requests.Request()
class FakeStreamWithConnectionError:
# fake object for urllib3.response.HTTPResponse
def __init__(self):
self.total_response_size = 500
def stream(self, chunk_size, decode_content=False):
assert chunk_size == block_size
left = total_response_size
while left > 0:
if left <= block_size:
raise requests.exceptions.ConnectionError()
data = b"X" * min(chunk_size, left)
left -= len(data)
yield data
def read(self, chunk_size, decode_content=False):
assert chunk_size == block_size
if self.total_response_size > 0:
if self.total_response_size <= block_size:
raise requests.exceptions.ConnectionError()
data = b"X" * min(chunk_size, self.total_response_size)
self.total_response_size -= len(data)
return data
def close(self):
pass
req_response.raw = FakeStreamWithConnectionError()
response = AsyncioRequestsTransportResponse(
req_request,
req_response,
block_size,
)
async def mock_run(self, *args, **kwargs):
return PipelineResponse(
None,
requests.Response(),
None,
)
transport = AioHttpTransport()
pipeline = AsyncPipeline(transport)
pipeline.run = mock_run
downloader = response.stream_download(pipeline)
with pytest.raises(requests.exceptions.ConnectionError):
while True:
await downloader.__anext__()
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 = AsyncBearerTokenCredentialPolicy(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,
credential_policy,
self._config.retry_policy,
SyncTokenPolicy(),
self._config.logging_policy, # HTTP request/response log
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = AsyncioRequestsTransport(**kwargs)
return AsyncPipeline(
transport,
policies,
)
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, six.string_types):
credential_policy = CognitiveServicesCredentialPolicy(credential)
elif credential is not None:
raise TypeError("Unsupported credential: {}".format(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)
async def test_bearer_policy_adds_header():
"""The bearer token policy should add a header containing a token from its credential"""
# 2524608000 == 01/01/2050 @ 12:00am (UTC)
expected_token = AccessToken("expected_token", 2524608000)
async def verify_authorization_header(request):
assert request.http_request.headers[
"Authorization"] == "Bearer {}".format(expected_token.token)
return Mock()
get_token_calls = 0
async def get_token(_):
nonlocal get_token_calls
get_token_calls += 1
return expected_token
fake_credential = Mock(get_token=get_token)
policies = [
AsyncBearerTokenCredentialPolicy(fake_credential, "scope"),
Mock(send=verify_authorization_header)
]
pipeline = AsyncPipeline(transport=Mock(), policies=policies)
await pipeline.run(HttpRequest("GET", "https://spam.eggs"), context=None)
assert get_token_calls == 1
await pipeline.run(HttpRequest("GET", "https://spam.eggs"), context=None)
# Didn't need a new token
assert get_token_calls == 1
def get_table_client(
self, table_name, # type: str
**kwargs # type: Optional[Any]
):
# type: (...) -> TableClient
"""Get a client to interact with the specified table.
The table need not already exist.
:param table:
The queue. This can either be the name of the queue,
or an instance of QueueProperties.
:type table: str or ~azure.storage.table.TableProperties
:returns: A :class:`~azure.data.tables.TableClient` object.
:rtype: ~azure.data.tables.TableClient
"""
_pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable = protected-access
policies=self._pipeline._impl_policies # pylint: disable = protected-access
)
return TableClient(
self.url, table_name=table_name, credential=self.credential,
key_resolver_function=self.key_resolver_function, require_encryption=self.require_encryption,
key_encryption_key=self.key_encryption_key, api_version=self.api_version, _pipeline=self._pipeline,
_configuration=self._config, _location_mode=self._location_mode, _hosts=self._hosts, **kwargs)
def __init__(self,
config: "Optional[Configuration]" = None,
policies: "Optional[Iterable[AsyncHTTPPolicy]]" = None,
transport: "Optional[AsyncHttpTransport]" = None,
**kwargs: "Any") -> None:
config = config or self._create_config(**kwargs)
policies = policies or [
config.retry_policy, config.logging_policy,
DistributedTracingPolicy()
]
self._transport = transport or AioHttpTransport(configuration=config)
atexit.register(
self._close_transport_session) # prevent aiohttp warnings
self._pipeline = AsyncPipeline(transport=self._transport,
policies=policies)
async def test_bearer_policy_optionally_enforces_https():
"""HTTPS enforcement should be controlled by a keyword argument, and enabled by default"""
async def assert_option_popped(request, **kwargs):
assert "enforce_https" not in kwargs, "AsyncBearerTokenCredentialPolicy didn't pop the 'enforce_https' option"
credential = Mock(get_token=lambda *_, **__: get_completed_future(
AccessToken("***", 42)))
pipeline = AsyncPipeline(
transport=Mock(send=assert_option_popped),
policies=[AsyncBearerTokenCredentialPolicy(credential, "scope")])
# by default and when enforce_https=True, the policy should raise when given an insecure request
with pytest.raises(ServiceRequestError):
await pipeline.run(HttpRequest("GET", "http://not.secure"))
with pytest.raises(ServiceRequestError):
await pipeline.run(HttpRequest("GET", "http://not.secure"),
enforce_https=True)
# when enforce_https=False, an insecure request should pass
await pipeline.run(HttpRequest("GET", "http://not.secure"),
enforce_https=False)
# https requests should always pass
await pipeline.run(HttpRequest("GET", "https://secure"),
enforce_https=False)
await pipeline.run(HttpRequest("GET", "https://secure"),
enforce_https=True)
await pipeline.run(HttpRequest("GET", "https://secure"))
async def test_multiple_claims_challenges():
"""ARMChallengeAuthenticationPolicy should not attempt to handle a response having multiple claims challenges"""
expected_header = ",".join((
'Bearer realm="", authorization_uri="https://login.microsoftonline.com/common/oauth2/authorize", client_id="00000003-0000-0000-c000-000000000000", error="insufficient_claims", claims="eyJhY2Nlc3NfdG9rZW4iOiB7ImZvbyI6ICJiYXIifX0="',
'Bearer authorization_uri="https://login.windows-ppe.net/", error="invalid_token", error_description="User session has been revoked", claims="eyJhY2Nlc3NfdG9rZW4iOnsibmJmIjp7ImVzc2VudGlhbCI6dHJ1ZSwgInZhbHVlIjoiMTYwMzc0MjgwMCJ9fX0="',
))
async def send(request):
return Mock(status_code=401,
headers={"WWW-Authenticate": expected_header})
async def get_token(*_, **__):
return AccessToken("***", 42)
transport = Mock(send=Mock(wraps=send))
credential = Mock(get_token=Mock(wraps=get_token))
policies = [AsyncARMChallengeAuthenticationPolicy(credential, "scope")]
pipeline = AsyncPipeline(transport=transport, policies=policies)
response = await pipeline.run(HttpRequest("GET", "https://localhost"))
assert transport.send.call_count == 1
assert credential.get_token.call_count == 1
# the policy should have returned the error response because it was unable to handle the challenge
assert response.http_response.status_code == 401
assert response.http_response.headers[
"WWW-Authenticate"] == expected_header
def get_table_client(
self,
table_name, # type: str
**kwargs # type: Optional[Any]
):
# type: (...) -> TableClient
"""Get a client to interact with the specified table.
The table need not already exist.
:param str table_name: The table name
:returns: A :class:`~azure.data.tables.aio.TableClient` object.
:rtype: :class:`~azure.data.tables.aio.TableClient`
"""
pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(self._client._client._pipeline._transport), # pylint:disable=protected-access
policies=self._policies,
)
return TableClient(
self.url,
table_name=table_name,
credential=self.credential,
api_version=self.api_version,
pipeline=pipeline,
location_mode=self._location_mode,
_hosts=self._hosts,
**kwargs
)
def get_subdirectory_client(self, directory_name, **kwargs):
# type: (str, Any) -> ShareDirectoryClient
"""Get a client to interact with a specific subdirectory.
The subdirectory need not already exist.
:param str directory_name:
The name of the subdirectory.
:returns: A Directory Client.
:rtype: ~azure.storage.fileshare.aio.ShareDirectoryClient
.. admonition:: Example:
.. literalinclude:: ../samples/file_samples_directory_async.py
:start-after: [START get_subdirectory_client]
:end-before: [END get_subdirectory_client]
:language: python
:dedent: 16
:caption: Gets the subdirectory client.
"""
directory_path = self.directory_path.rstrip('/') + "/" + directory_name
_pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable = protected-access
policies=self._pipeline._impl_policies # pylint: disable = protected-access
)
return ShareDirectoryClient(
self.url, share_name=self.share_name, directory_path=directory_path, snapshot=self.snapshot,
credential=self.credential, api_version=self.api_version, _hosts=self._hosts, _configuration=self._config,
_pipeline=_pipeline, _location_mode=self._location_mode, loop=self._loop, **kwargs)
async def test_preserves_options_and_headers():
"""After a challenge, the original request should be sent with its options and headers preserved.
If a policy mutates the options or headers of the challenge (unauthorized) request, the options of the service
request should be present when it is sent with authorization.
"""
url = get_random_url()
token = "**"
async def get_token(*_, **__):
return AccessToken(token, 0)
credential = Mock(get_token=Mock(wraps=get_token))
transport = async_validating_transport(
requests=[Request()] * 2 + [Request(required_headers={"Authorization": "Bearer " + token})],
responses=[
mock_response(
status_code=401, headers={"WWW-Authenticate": 'Bearer authorization="{}", resource=foo'.format(url)}
)
]
+ [mock_response()] * 2,
)
challenge_policy = AsyncChallengeAuthPolicy(credential=credential)
policies = get_policies_for_request_mutation_test(challenge_policy)
pipeline = AsyncPipeline(policies=policies, transport=transport)
response = await pipeline.run(HttpRequest("GET", url))
# ensure the mock sans I/O policies were used
for policy in policies:
if hasattr(policy, "on_request"):
assert policy.on_request.called, "mock policy wasn't invoked"
async def test_retry_timeout():
class MockTransport(AsyncHttpTransport):
def __init__(self):
self.count = 0
async def __aexit__(self, exc_type, exc_val, exc_tb):
pass
async def close(self):
pass
async def open(self):
pass
async def send(
self, request,
**kwargs): # type: (PipelineRequest, Any) -> PipelineResponse
self.count += 1
if self.count > 2:
assert self.count <= 2
time.sleep(0.5)
raise ServiceResponseError('timeout')
http_request = HttpRequest('GET', 'http://127.0.0.1/')
headers = {'Content-Type': "multipart/form-data"}
http_request.headers = headers
http_retry = AsyncRetryPolicy(retry_total=10, timeout=1)
pipeline = AsyncPipeline(MockTransport(), [http_retry])
with pytest.raises(ServiceResponseTimeoutError):
await pipeline.run(http_request)
async def test_bearer_policy_adds_header():
"""The bearer token policy should add a header containing a token from its credential"""
expected_token = "expected_token"
async def verify_authorization_header(request):
assert request.http_request.headers[
"Authorization"] == "Bearer {}".format(expected_token)
get_token_calls = 0
async def get_token(_):
nonlocal get_token_calls
get_token_calls += 1
return expected_token
fake_credential = Mock(get_token=get_token)
policies = [
AsyncBearerTokenCredentialPolicy(credential=fake_credential,
scopes=("", )),
Mock(spec=HTTPPolicy, send=verify_authorization_header),
]
pipeline = AsyncPipeline(transport=Mock(spec=AsyncHttpTransport),
policies=policies)
await pipeline.run(HttpRequest("GET", "https://spam.eggs"), context=None)
assert get_token_calls == 1
async def test_retry_seekable_stream():
class MockTransport(AsyncHttpTransport):
def __init__(self):
self._first = True
async def __aexit__(self, exc_type, exc_val, exc_tb):
pass
async def close(self):
pass
async def open(self):
pass
async def send(
self, request,
**kwargs): # type: (PipelineRequest, Any) -> PipelineResponse
if self._first:
self._first = False
request.body.seek(0, 2)
raise AzureError('fail on first')
position = request.body.tell()
assert position == 0
response = HttpResponse(request, None)
response.status_code = 400
return response
data = BytesIO(b"Lots of dataaaa")
http_request = HttpRequest('GET', 'http://127.0.0.1/')
http_request.set_streamed_data_body(data)
http_retry = AsyncRetryPolicy(retry_total=1)
pipeline = AsyncPipeline(MockTransport(), [http_retry])
await pipeline.run(http_request)
async def test_retry_on_429():
class MockTransport(AsyncHttpTransport):
def __init__(self):
self._count = 0
async def __aexit__(self, exc_type, exc_val, exc_tb):
pass
async def close(self):
pass
async def open(self):
pass
async def send(
self, request,
**kwargs): # type: (PipelineRequest, Any) -> PipelineResponse
self._count += 1
response = HttpResponse(request, None)
response.status_code = 429
return response
http_request = HttpRequest('GET', 'http://127.0.0.1/')
http_retry = AsyncRetryPolicy(retry_total=1)
transport = MockTransport()
pipeline = AsyncPipeline(transport, [http_retry])
await pipeline.run(http_request)
assert transport._count == 2
async def do():
conf = Configuration()
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(TrioRequestsTransport(conf),
policies=policies) as pipeline:
return await pipeline.run(request)
def get_file_client(self, file_name, **kwargs):
# type: (str, Any) -> ShareFileClient
"""Get a client to interact with a specific file.
The file need not already exist.
:param str file_name:
The name of the file.
:returns: A File Client.
:rtype: ~azure.storage.fileshare.ShareFileClient
"""
if self.directory_path:
file_name = self.directory_path.rstrip('/') + "/" + file_name
_pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(
self._pipeline._transport
), # pylint: disable = protected-access
policies=self._pipeline.
_impl_policies # pylint: disable = protected-access
)
return ShareFileClient(self.url,
file_path=file_name,
share_name=self.share_name,
snapshot=self.snapshot,
credential=self.credential,
_hosts=self._hosts,
_configuration=self._config,
_pipeline=_pipeline,
_location_mode=self._location_mode,
loop=self._loop,
**kwargs)
async def test_no_retry_on_201(http_request):
class MockTransport(AsyncHttpTransport):
def __init__(self):
self._count = 0
async def __aexit__(self, exc_type, exc_val, exc_tb):
pass
async def close(self):
pass
async def open(self):
pass
async def send(
self, request,
**kwargs): # type: (PipelineRequest, Any) -> PipelineResponse
self._count += 1
response = HttpResponse(request, None)
response.status_code = 201
headers = {"Retry-After": "1"}
response.headers = headers
return response
http_request = http_request('GET', 'http://localhost/')
http_retry = AsyncRetryPolicy(retry_total=1)
transport = MockTransport()
pipeline = AsyncPipeline(transport, [http_retry])
await pipeline.run(http_request)
assert transport._count == 1
def get_directory_client(self, directory_path=None):
# type: (Optional[str]) -> ShareDirectoryClient
"""Get a client to interact with the specified directory.
The directory need not already exist.
:param str directory_path:
Path to the specified directory.
:returns: A Directory Client.
:rtype: ~azure.storage.fileshare.aio.ShareDirectoryClient
"""
_pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(
self._pipeline._transport
), # pylint: disable = protected-access
policies=self._pipeline.
_impl_policies # pylint: disable = protected-access
)
return ShareDirectoryClient(self.url,
share_name=self.share_name,
directory_path=directory_path or "",
snapshot=self.snapshot,
credential=self.credential,
api_version=self.api_version,
_hosts=self._hosts,
_configuration=self._config,
_pipeline=_pipeline,
_location_mode=self._location_mode,
loop=self._loop)
async def do():
request = HttpRequest("GET",
"http://localhost:{}/basic/string".format(port))
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(TrioRequestsTransport(),
policies=policies) as pipeline:
return await pipeline.run(request)
def get_file_client(self, file_path):
# type: (str) -> ShareFileClient
"""Get a client to interact with the specified file.
The file need not already exist.
:param str file_path:
Path to the specified file.
:returns: A File Client.
:rtype: ~azure.storage.fileshare.aio.ShareFileClient
"""
_pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(
self._pipeline._transport
), # pylint: disable = protected-access
policies=self._pipeline.
_impl_policies # pylint: disable = protected-access
)
return ShareFileClient(self.url,
share_name=self.share_name,
file_path=file_path,
snapshot=self.snapshot,
credential=self.credential,
api_version=self.api_version,
_hosts=self._hosts,
_configuration=self._config,
_pipeline=_pipeline,
_location_mode=self._location_mode,
loop=self._loop)
def _build_pipeline(self, **kwargs): # pylint: disable=no-self-use
transport = kwargs.get('transport')
policies = kwargs.get('policies')
credential_policy = \
AsyncServiceBusSharedKeyCredentialPolicy(self._endpoint, self._credential, "Authorization") \
if isinstance(self._credential, ServiceBusSharedKeyCredential) \
else AsyncBearerTokenCredentialPolicy(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),
ServiceBusXMLWorkaroundPolicy(),
self._config.redirect_policy,
self._config.retry_policy,
credential_policy,
self._config.logging_policy,
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = AioHttpTransport(**kwargs)
return AsyncPipeline(transport, policies)
def get_repository(self, repository_name: str,
**kwargs: Any) -> ContainerRepository:
"""Get a repository client
:param str repository_name: The repository to create a client for
:returns: :class:`~azure.containerregistry.aio.ContainerRepository`
Example
.. code-block:: python
from azure.containerregistry.aio import ContainerRepositoryClient
from azure.identity.aio import DefaultAzureCredential
account_url = os.environ["CONTAINERREGISTRY_ENDPOINT"]
client = ContainerRegistryClient(account_url, DefaultAzureCredential())
repository_client = client.get_repository_client("my_repository")
"""
_pipeline = AsyncPipeline(
transport=AsyncTransportWrapper(
self._client._client._pipeline._transport # pylint: disable=protected-access
),
policies=self._client._client._pipeline._impl_policies, # pylint: disable=protected-access
)
return ContainerRepository(self._endpoint,
repository_name,
credential=self._credential,
pipeline=_pipeline,
**kwargs)
async def test_with_challenge(challenge, expected_scope):
expected_token = "expected_token"
class Requests:
count = 0
async def send(request):
Requests.count += 1
if Requests.count == 1:
# first request should be unauthorized and have no content
assert not request.body
assert request.headers["Content-Length"] == "0"
return challenge
elif Requests.count == 2:
# second request should be authorized according to challenge and have the expected content
assert request.headers["Content-Length"]
assert request.body == expected_content
assert expected_token in request.headers["Authorization"]
return Mock(status_code=200)
raise ValueError("unexpected request")
async def get_token(*scopes):
assert len(scopes) == 1
assert scopes[0] == expected_scope
return AccessToken(expected_token, 0)
credential = Mock(get_token=Mock(wraps=get_token))
pipeline = AsyncPipeline(
policies=[AsyncChallengeAuthPolicy(credential=credential)],
transport=Mock(send=send))
request = HttpRequest("POST", get_random_url())
request.set_bytes_body(expected_content)
await pipeline.run(request)
assert credential.get_token.call_count == 1
async def test_enforces_tls():
url = "http://not.secure"
HttpChallengeCache.set_challenge_for_url(url, HttpChallenge(url, "Bearer authorization=_, resource=_"))
credential = Mock()
pipeline = AsyncPipeline(transport=Mock(), policies=[AsyncChallengeAuthPolicy(credential)])
with pytest.raises(ServiceRequestError):
await pipeline.run(HttpRequest("GET", url))
async def test_basic_options_aiohttp():
request = HttpRequest("OPTIONS", "https://httpbin.org")
async with AsyncPipeline(AioHttpTransport(), policies=[]) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert isinstance(response.http_response.status_code, int)
async def test_basic_options_aiohttp(port):
request = HttpRequest("OPTIONS", "http://localhost:{}/basic/string".format(port))
async with AsyncPipeline(AioHttpTransport(), policies=[]) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert isinstance(response.http_response.status_code, int)
