async def test_set_cors(self, resource_group, location, storage_account,
storage_account_key):
# Arrange
qsc = QueueServiceClient(self.account_url(storage_account, "queue"),
storage_account_key,
transport=AiohttpTestTransport())
cors_rule1 = CorsRule(['www.xyz.com'], ['GET'])
allowed_origins = ['www.xyz.com', "www.ab.com", "www.bc.com"]
allowed_methods = ['GET', 'PUT']
max_age_in_seconds = 500
exposed_headers = [
"x-ms-meta-data*", "x-ms-meta-source*", "x-ms-meta-abc",
"x-ms-meta-bcd"
]
allowed_headers = [
"x-ms-meta-data*", "x-ms-meta-target*", "x-ms-meta-xyz",
"x-ms-meta-foo"
]
cors_rule2 = CorsRule(allowed_origins,
allowed_methods,
max_age_in_seconds=max_age_in_seconds,
exposed_headers=exposed_headers,
allowed_headers=allowed_headers)
cors = [cors_rule1, cors_rule2]
# Act
await qsc.set_service_properties(cors=cors)
# Assert
received_props = await qsc.get_service_properties()
self._assert_cors_equal(received_props['cors'], cors)
async def test_sas_add(self, resource_group, location, storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# SAS URL is calculated from storage key, so this test runs live only
if self.is_playback():
return
# Arrange
queue_client = await self._create_queue(qsc)
token = queue_client.generate_shared_access_signature(
QueueSasPermissions(add=True),
datetime.utcnow() + timedelta(hours=1),
)
# Act
service = QueueClient(
queue_url=queue_client.url,
credential=token,
)
result = await service.enqueue_message(u'addedmessage')
# Assert
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
result = messages[0]
self.assertEqual(u'addedmessage', result.content)
async def test_sas_process(self, resource_group, location, storage_account, storage_account_key):
qsc = QueueServiceClient(self.account_url(storage_account.name, "queue"), storage_account_key, transport=AiohttpTestTransport())
# SAS URL is calculated from storage key, so this test runs live only
# Arrange
queue_client = await self._create_queue(qsc)
await queue_client.send_message(u'message1')
token = generate_queue_sas(
queue_client.account_name,
queue_client.queue_name,
queue_client.credential.account_key,
QueueSasPermissions(process=True),
datetime.utcnow() + timedelta(hours=1),
)
# Act
service = QueueClient.from_queue_url(
queue_url=queue_client.url,
credential=token,
)
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
message = messages[0]
# Assert
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertEqual(u'message1', message.content)
async def queues_in_account_async(self):
# Instantiate the QueueServiceClient from a connection string
from azure.storage.queue.aio import QueueServiceClient
queue_service = QueueServiceClient.from_connection_string(
conn_str=self.connection_string)
async with queue_service:
# [START async_qsc_create_queue]
await queue_service.create_queue("myqueue1")
# [END async_qsc_create_queue]
try:
# [START async_qsc_list_queues]
# List all the queues in the service
list_queues = queue_service.list_queues()
async for queue in list_queues:
print(queue)
# List the queues in the service that start with the name "my_"
list_my_queues = queue_service.list_queues(
name_starts_with="my_")
async for queue in list_my_queues:
print(queue)
# [END async_qsc_list_queues]
finally:
# [START async_qsc_delete_queue]
await queue_service.delete_queue("myqueue1")
async def test_message_base64_decode_fails(self, resource_group, location,
storage_account,
storage_account_key):
# Arrange
qsc = QueueServiceClient(self.account_url(storage_account.name,
"queue"),
storage_account_key,
transport=AiohttpTestTransport())
queue = QueueClient(
account_url=self.account_url(storage_account.name, "queue"),
queue_name=self.get_resource_name(TEST_QUEUE_PREFIX),
credential=storage_account_key,
message_encode_policy=None,
message_decode_policy=BinaryBase64DecodePolicy(),
transport=AiohttpTestTransport())
try:
await queue.create_queue()
except ResourceExistsError:
pass
message = u'xyz'
await queue.send_message(message)
# Action.
with self.assertRaises(DecodeError) as e:
await queue.peek_messages()
# Asserts
self.assertNotEqual(
-1,
str(e.exception).find('Message content is not valid base 64'))
async def test_get_messages_with_options(self, resource_group, location, storage_account, storage_account_key):
# Action
qsc = QueueServiceClient(self.account_url(storage_account.name, "queue"), storage_account_key, transport=AiohttpTestTransport())
queue_client = await self._create_queue(qsc)
await queue_client.send_message(u'message1')
await queue_client.send_message(u'message2')
await queue_client.send_message(u'message3')
await queue_client.send_message(u'message4')
pager = queue_client.receive_messages(messages_per_page=4, visibility_timeout=20)
result = []
async for el in pager:
result.append(el)
# Asserts
self.assertIsNotNone(result)
self.assertEqual(4, len(result))
for message in result:
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertNotEqual('', message.content)
self.assertNotEqual('', message.pop_receipt)
self.assertEqual(1, message.dequeue_count)
self.assertNotEqual('', message.inserted_on)
self.assertNotEqual('', message.expires_on)
self.assertNotEqual('', message.next_visible_on)
async def test_peek_messages_encrypted_kek(self, resource_group, location,
storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# Arrange
qsc.key_encryption_key = KeyWrapper('key1')
queue = await self._create_queue(qsc)
await queue.enqueue_message(u'encrypted_message_3')
# Act
li = await queue.peek_messages()
# Assert
self.assertEqual(li[0].content, u'encrypted_message_3')
async def test_sas_read(self, resource_group, location, storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# SAS URL is calculated from storage key, so this test runs live only
if self.is_playback():
return
# Arrange
queue_client = await self._create_queue(qsc)
await queue_client.enqueue_message(u'message1')
token = queue_client.generate_shared_access_signature(
QueuePermissions.READ,
datetime.utcnow() + timedelta(hours=1),
datetime.utcnow() - timedelta(minutes=5))
# Act
service = QueueClient(
queue_url=queue_client.url,
credential=token,
)
result = await service.peek_messages()
# Assert
self.assertIsNotNone(result)
self.assertEqual(1, len(result))
message = result[0]
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertEqual(u'message1', message.content)
async def test_peek_messages_encrypted_resolver(self, resource_group, location, storage_account, storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name), storage_account_key, transport=AiohttpTestTransport())
# Arrange
qsc.key_encryption_key = KeyWrapper('key1')
queue = await self._create_queue(qsc)
await queue.send_message(u'encrypted_message_4')
key_resolver = KeyResolver()
key_resolver.put_key(qsc.key_encryption_key)
queue.key_resolver_function = key_resolver.resolve_key
queue.key_encryption_key = None # Ensure that the resolver is used
# Act
li = await queue.peek_messages()
# Assert
self.assertEqual(li[0].content, u'encrypted_message_4')
async def test_update_encrypted_json_message(self, resource_group, location, storage_account, storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name), storage_account_key, transport=AiohttpTestTransport())
# TODO: Recording doesn't work
if not self.is_live:
return
# Arrange
queue = await self._create_queue(qsc, message_encode_policy=None, message_decode_policy=None)
queue.key_encryption_key = KeyWrapper('key1')
message_dict = {'val1': 1, 'val2': '2'}
json_text = dumps(message_dict)
await queue.send_message(json_text)
messages = []
async for m in queue.receive_messages():
messages.append(m)
list_result1 = messages[0]
# Act
message_dict['val1'] = 0
message_dict['val2'] = 'updated'
json_text = dumps(message_dict)
list_result1.content = json_text
await queue.update_message(list_result1)
async for m in queue.receive_messages():
messages.append(m)
list_result2 = messages[0]
# Assert
self.assertEqual(message_dict, loads(list_result2.content))
async def test_user_agent_custom(self, resource_group, location, storage_account, storage_account_key):
custom_app = "TestApp/v1.0"
service = QueueServiceClient(
self.account_url(storage_account.name, "queue"), credential=storage_account_key, user_agent=custom_app, transport=AiohttpTestTransport())
def callback(response):
self.assertTrue('User-Agent' in response.http_request.headers)
self.assertEqual(
response.http_request.headers['User-Agent'],
"TestApp/v1.0 azsdk-python-storage-queue/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform()))
await service.get_service_properties(raw_response_hook=callback)
def callback(response):
self.assertTrue('User-Agent' in response.http_request.headers)
self.assertEqual(
response.http_request.headers['User-Agent'],
"TestApp/v2.0 azsdk-python-storage-queue/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform()))
await service.get_service_properties(raw_response_hook=callback, user_agent="TestApp/v2.0")
def test_create_service_with_custom_account_endpoint_path(self, resource_group, location, storage_account, storage_account_key):
custom_account_url = "http://local-machine:11002/custom/account/path/" + self.sas_token
for service_type in SERVICES.items():
conn_string = 'DefaultEndpointsProtocol=http;AccountName={};AccountKey={};QueueEndpoint={};'.format(
storage_account.name, storage_account_key, custom_account_url)
# Act
service = service_type[0].from_connection_string(conn_string, queue_name="foo")
# Assert
self.assertEqual(service.account_name, storage_account.name)
self.assertEqual(service.credential.account_name, storage_account.name)
self.assertEqual(service.credential.account_key, storage_account_key)
self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path')
service = QueueServiceClient(account_url=custom_account_url)
self.assertEqual(service.account_name, None)
self.assertEqual(service.credential, None)
self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path')
self.assertTrue(service.url.startswith('http://local-machine:11002/custom/account/path/?'))
service = QueueClient(account_url=custom_account_url, queue_name="foo")
self.assertEqual(service.account_name, None)
self.assertEqual(service.queue_name, "foo")
self.assertEqual(service.credential, None)
self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path')
self.assertTrue(service.url.startswith('http://local-machine:11002/custom/account/path/foo?'))
service = QueueClient.from_queue_url("http://local-machine:11002/custom/account/path/foo" + self.sas_token)
self.assertEqual(service.account_name, None)
self.assertEqual(service.queue_name, "foo")
self.assertEqual(service.credential, None)
self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path')
self.assertTrue(service.url.startswith('http://local-machine:11002/custom/account/path/foo?'))
async def test_queues_in_account(self, resource_group, location,
storage_account, storage_account_key):
# Instantiate the QueueServiceClient from a connection string
from azure.storage.queue.aio import QueueServiceClient
queue_service = QueueServiceClient.from_connection_string(
self.connection_string(storage_account, storage_account_key))
# [START async_qsc_create_queue]
await queue_service.create_queue("asynctestqueue")
# [END async_qsc_create_queue]
try:
# [START async_qsc_list_queues]
# List all the queues in the service
list_queues = queue_service.list_queues()
async for queue in list_queues:
print(queue)
# List the queues in the service that start with the name "test"
list_test_queues = queue_service.list_queues(
name_starts_with="test")
async for queue in list_test_queues:
print(queue)
# [END async_qsc_list_queues]
finally:
# [START async_qsc_delete_queue]
await queue_service.delete_queue("asynctestqueue")
async def test_retention_no_days(self, resource_group, location,
storage_account, storage_account_key):
# Assert
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
self.assertRaises(ValueError, RetentionPolicy, True, None)
async def test_update_encrypted_message(self, resource_group, location,
storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# TODO: Recording doesn't work
if not self.is_live:
return
# Arrange
queue = await self._create_queue(qsc)
queue.key_encryption_key = KeyWrapper('key1')
await queue.enqueue_message(u'Update Me')
messages = []
async for m in queue.receive_messages():
messages.append(m)
list_result1 = messages[0]
list_result1.content = u'Updated'
# Act
message = await queue.update_message(list_result1)
async for m in queue.receive_messages():
messages.append(m)
list_result2 = messages[0]
# Assert
self.assertEqual(u'Updated', list_result2.content)
async def test_peek_messages_with_options(self, resource_group, location,
storage_account,
storage_account_key):
# Action
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
queue_client = await self._create_queue(qsc)
await queue_client.enqueue_message(u'message1')
await queue_client.enqueue_message(u'message2')
await queue_client.enqueue_message(u'message3')
await queue_client.enqueue_message(u'message4')
result = await queue_client.peek_messages(max_messages=4)
# Asserts
self.assertIsNotNone(result)
self.assertEqual(4, len(result))
for message in result:
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertNotEqual('', message.content)
self.assertIsNone(message.pop_receipt)
self.assertEqual(0, message.dequeue_count)
self.assertNotEqual('', message.insertion_time)
self.assertNotEqual('', message.expiration_time)
self.assertIsNone(message.time_next_visible)
async def test_update_encrypted_binary_message(self, resource_group,
location, storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# Arrange
queue = await self._create_queue(qsc)
queue.key_encryption_key = KeyWrapper('key1')
queue._config.message_encode_policy = BinaryBase64EncodePolicy()
queue._config.message_decode_policy = BinaryBase64DecodePolicy()
binary_message = self.get_random_bytes(100)
await queue.enqueue_message(binary_message)
messages = []
async for m in queue.receive_messages():
messages.append(m)
list_result1 = messages[0]
# Act
binary_message = self.get_random_bytes(100)
list_result1.content = binary_message
await queue.update_message(list_result1)
async for m in queue.receive_messages():
messages.append(m)
list_result2 = messages[0]
# Assert
self.assertEqual(binary_message, list_result2.content)
async def test_sas_process(self, resource_group, location, storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# SAS URL is calculated from storage key, so this test runs live only
if self.is_playback():
return
# Arrange
queue_client = await self._create_queue(qsc)
await queue_client.enqueue_message(u'message1')
token = queue_client.generate_shared_access_signature(
QueuePermissions.PROCESS,
datetime.utcnow() + timedelta(hours=1),
)
# Act
service = QueueClient(
queue_url=queue_client.url,
credential=token,
)
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
message = messages[0]
# Assert
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertEqual(u'message1', message.content)
async def test_update_encrypted_raw_text_message(self, resource_group,
location, storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# TODO: Recording doesn't work
if not self.is_live:
return
# Arrange
queue = await self._create_queue(qsc)
queue.key_encryption_key = KeyWrapper('key1')
queue._config.message_encode_policy = NoEncodePolicy()
queue._config.message_decode_policy = NoDecodePolicy()
raw_text = u'Update Me'
await queue.enqueue_message(raw_text)
messages = []
async for m in queue.receive_messages():
messages.append(m)
list_result1 = messages[0]
# Act
raw_text = u'Updated'
list_result1.content = raw_text
async for m in queue.receive_messages():
messages.append(m)
list_result2 = messages[0]
# Assert
self.assertEqual(raw_text, list_result2.content)
async def test_get_messages(self, resource_group, location, storage_account, storage_account_key):
# Action
qsc = QueueServiceClient(self.account_url(storage_account.name, "queue"), storage_account_key, transport=AiohttpTestTransport())
queue_client = await self._create_queue(qsc)
await queue_client.send_message(u'message1')
await queue_client.send_message(u'message2')
await queue_client.send_message(u'message3')
await queue_client.send_message(u'message4')
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
if len(messages):
break
message = messages[0]
# Asserts
self.assertIsNotNone(message)
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertEqual(u'message1', message.content)
self.assertNotEqual('', message.pop_receipt)
self.assertEqual(1, message.dequeue_count)
self.assertIsInstance(message.inserted_on, datetime)
self.assertIsInstance(message.expires_on, datetime)
self.assertIsInstance(message.next_visible_on, datetime)
async def test_invalid_value_kek_wrap(self, resource_group, location,
storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# Arrange
queue = await self._create_queue(qsc)
queue.key_encryption_key = KeyWrapper('key1')
queue.key_encryption_key.get_kid = None
with self.assertRaises(AttributeError) as e:
await queue.enqueue_message(u'message')
self.assertEqual(
str(e.exception),
_ERROR_OBJECT_INVALID.format('key encryption key', 'get_kid'))
queue.key_encryption_key = KeyWrapper('key1')
queue.key_encryption_key.get_kid = None
with self.assertRaises(AttributeError):
await queue.enqueue_message(u'message')
queue.key_encryption_key = KeyWrapper('key1')
queue.key_encryption_key.wrap_key = None
with self.assertRaises(AttributeError):
await queue.enqueue_message(u'message')
async def test_sas_read(self, resource_group, location, storage_account, storage_account_key):
qsc = QueueServiceClient(self.account_url(storage_account.name, "queue"), storage_account_key, transport=AiohttpTestTransport())
# SAS URL is calculated from storage key, so this test runs live only
# Arrange
queue_client = await self._create_queue(qsc)
await queue_client.send_message(u'message1')
token = generate_queue_sas(
queue_client.account_name,
queue_client.queue_name,
queue_client.credential.account_key,
QueueSasPermissions(read=True),
datetime.utcnow() + timedelta(hours=1),
datetime.utcnow() - timedelta(minutes=5)
)
# Act
service = QueueClient.from_queue_url(
queue_url=queue_client.url,
credential=token,
)
result = await service.peek_messages()
# Assert
self.assertIsNotNone(result)
self.assertEqual(1, len(result))
message = result[0]
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertEqual(u'message1', message.content)
async def test_missing_attribute_kek_wrap(self, resource_group, location,
storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# Arrange
queue = await self._create_queue(qsc)
valid_key = KeyWrapper('key1')
# Act
invalid_key_1 = lambda: None # functions are objects, so this effectively creates an empty object
invalid_key_1.get_key_wrap_algorithm = valid_key.get_key_wrap_algorithm
invalid_key_1.get_kid = valid_key.get_kid
# No attribute wrap_key
queue.key_encryption_key = invalid_key_1
with self.assertRaises(AttributeError):
await queue.enqueue_message(u'message')
invalid_key_2 = lambda: None # functions are objects, so this effectively creates an empty object
invalid_key_2.wrap_key = valid_key.wrap_key
invalid_key_2.get_kid = valid_key.get_kid
# No attribute get_key_wrap_algorithm
queue.key_encryption_key = invalid_key_2
with self.assertRaises(AttributeError):
await queue.enqueue_message(u'message')
invalid_key_3 = lambda: None # functions are objects, so this effectively creates an empty object
invalid_key_3.get_key_wrap_algorithm = valid_key.get_key_wrap_algorithm
invalid_key_3.wrap_key = valid_key.wrap_key
# No attribute get_kid
queue.key_encryption_key = invalid_key_3
with self.assertRaises(AttributeError):
await queue.enqueue_message(u'message')
async def test_unicode_update_message_unicode_data(self, resource_group, location, storage_account, storage_account_key):
# Action
qsc = QueueServiceClient(self.account_url(storage_account.name, "queue"), storage_account_key, transport=AiohttpTestTransport())
queue_client = await self._create_queue(qsc)
await queue_client.send_message(u'message1')
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
list_result1 = messages[0]
list_result1.content = u'啊齄丂狛狜'
await queue_client.update_message(list_result1, visibility_timeout=0)
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
# Asserts
message = messages[0]
self.assertIsNotNone(message)
self.assertEqual(list_result1.id, message.id)
self.assertEqual(u'啊齄丂狛狜', message.content)
self.assertNotEqual('', message.pop_receipt)
self.assertEqual(2, message.dequeue_count)
self.assertIsInstance(message.inserted_on, datetime)
self.assertIsInstance(message.expires_on, datetime)
self.assertIsInstance(message.next_visible_on, datetime)
async def test_missing_attribute_kek_unrwap(self, resource_group, location,
storage_account,
storage_account_key):
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
# Arrange
queue = await self._create_queue(qsc)
queue.key_encryption_key = KeyWrapper('key1')
await queue.enqueue_message(u'message')
# Act
valid_key = KeyWrapper('key1')
invalid_key_1 = lambda: None # functions are objects, so this effectively creates an empty object
invalid_key_1.unwrap_key = valid_key.unwrap_key
# No attribute get_kid
queue.key_encryption_key = invalid_key_1
with self.assertRaises(HttpResponseError) as e:
await queue.peek_messages()
self.assertEqual(str(e.exception), "Decryption failed.")
invalid_key_2 = lambda: None # functions are objects, so this effectively creates an empty object
invalid_key_2.get_kid = valid_key.get_kid
# No attribute unwrap_key
queue.key_encryption_key = invalid_key_2
with self.assertRaises(HttpResponseError):
await queue.peek_messages()
async def test_auth_shared_access_signature(self, resource_group, location,
storage_account,
storage_account_key):
# Instantiate a QueueServiceClient using a connection string
from azure.storage.queue.aio import QueueServiceClient
queue_service = QueueServiceClient(
self._account_url(storage_account.name), storage_account_key)
# Create a SAS token to use for authentication of a client
sas_token = queue_service.generate_shared_access_signature(
resource_types="object",
permission="read",
expiry=datetime.utcnow() + timedelta(hours=1))
assert sas_token is not None
async def test_set_queue_acl_with_signed_identifiers(
self, resource_group, location, storage_account,
storage_account_key):
# Arrange
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
queue_client = await self._create_queue(qsc)
# Act
access_policy = AccessPolicy(
permission=QueuePermissions.READ,
expiry=datetime.utcnow() + timedelta(hours=1),
start=datetime.utcnow() - timedelta(minutes=5))
identifiers = {'testid': access_policy}
resp = await queue_client.set_queue_access_policy(
signed_identifiers=identifiers)
# Assert
self.assertIsNone(resp)
acl = await queue_client.get_queue_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 1)
self.assertTrue('testid' in acl)
async def test_response_callback(self, resource_group, location,
storage_account, storage_account_key):
# Arrange
service = QueueServiceClient(self._account_url(storage_account.name),
credential=storage_account_key,
transport=AiohttpTestTransport())
name = self.get_resource_name('cont')
queue = service.get_queue_client(name)
# Act
def callback(response):
response.http_response.status_code = 200
# Assert
exists = await queue.get_queue_properties(raw_response_hook=callback)
self.assertTrue(exists)
async def test_user_agent_default(self, storage_account_name, storage_account_key):
service = QueueServiceClient(self.account_url(storage_account_name, "queue"), credential=storage_account_key, transport=AiohttpTestTransport())
def callback(response):
self.assertTrue('User-Agent' in response.http_request.headers)
assert "azsdk-python-storage-queue/{}".format(VERSION) in response.http_request.headers['User-Agent']
await service.get_service_properties(raw_response_hook=callback)
async def test_queue_service_stats_f(self, resource_group, location, storage_account, storage_account_key):
# Arrange
qsc = QueueServiceClient(self.account_url(storage_account, "queue"), storage_account_key, transport=AiohttpTestTransport())
# Act
stats = await qsc.get_service_stats(raw_response_hook=self.override_response_body_with_live_status)
# Assert
self._assert_stats_default(stats)
