async def test_account_sas(self, resource_group, location, storage_account,
storage_account_key):
# SAS URL is calculated from storage key, so this test runs live only
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
if self.is_playback():
return
# Arrange
queue_client = await self._create_queue(qsc)
await queue_client.enqueue_message(u'message1')
token = qsc.generate_shared_access_signature(
ResourceTypes.OBJECT, AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
datetime.utcnow() - timedelta(minutes=5))
# Act
service = QueueServiceClient(
account_url=qsc.url,
credential=token,
)
new_queue_client = service.get_queue_client(queue_client.queue_name)
result = await new_queue_client.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_account_sas(self, resource_group, location, storage_account,
storage_account_key):
# SAS URL is calculated from storage key, so this test runs live only
qsc = QueueServiceClient(self.account_url(storage_account, "queue"),
storage_account_key,
transport=AiohttpTestTransport())
# Arrange
queue_client = await self._create_queue(qsc)
await queue_client.send_message(u'message1')
token = generate_account_sas(qsc.account_name,
qsc.credential.account_key,
ResourceTypes(object=True),
AccountSasPermissions(read=True),
datetime.utcnow() + timedelta(hours=1),
datetime.utcnow() - timedelta(minutes=5))
# Act
service = QueueServiceClient(
account_url=qsc.url,
credential=token,
)
new_queue_client = service.get_queue_client(queue_client.queue_name)
result = await new_queue_client.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_queue_not_exists(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 = qsc.get_queue_client(self.get_resource_name('missing'))
# Act
with self.assertRaises(ResourceNotFoundError):
await queue.get_queue_properties()
async def _test_account_sas(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
token = self.qsc.generate_shared_access_signature(
ResourceTypes.OBJECT, AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
datetime.utcnow() - timedelta(minutes=5))
# Act
service = QueueServiceClient(
account_url=self.qsc.url,
credential=token,
)
new_queue_client = service.get_queue_client(queue_client.queue_name)
result = await new_queue_client.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_unicode_create_queue_unicode_name(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_name = u'啊齄丂狛狜'
with self.assertRaises(HttpResponseError):
# not supported - queue name must be alphanumeric, lowercase
client = qsc.get_queue_client(queue_name)
await client.create_queue()
async def test_message_text_xml(self, resource_group, location,
storage_account, storage_account_key):
# Arrange.
qsc = QueueServiceClient(self._account_url(storage_account.name),
storage_account_key,
transport=AiohttpTestTransport())
message = u'<message1>'
queue = qsc.get_queue_client(self.get_resource_name(TEST_QUEUE_PREFIX))
# Asserts
await self._validate_encoding(queue, message)
async def test_message_text_xml_whitespace(self, storage_account_name,
storage_account_key):
# Arrange.
qsc = QueueServiceClient(self.account_url(storage_account_name,
"queue"),
storage_account_key,
transport=AiohttpTestTransport())
message = u' mess\t age1\n'
queue = qsc.get_queue_client(self.get_resource_name(TEST_QUEUE_PREFIX))
# Asserts
await self._validate_encoding(queue, message)
async def test_response_callback(self, resource_group, location, storage_account, storage_account_key):
# Arrange
service = QueueServiceClient(self.account_url(storage_account, "queue"), 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)
def test_service_client_api_version_property(self):
service_client = QueueServiceClient(
"https://foo.queue.core.windows.net/account",
credential="fake_key")
self.assertEqual(service_client.api_version, self.api_version_2)
self.assertEqual(service_client._client._config.version,
self.api_version_2)
with pytest.raises(AttributeError):
service_client.api_version = "foo"
service_client = QueueServiceClient(
"https://foo.queue.core.windows.net/account",
credential="fake_key",
api_version=self.api_version_1)
self.assertEqual(service_client.api_version, self.api_version_1)
self.assertEqual(service_client._client._config.version,
self.api_version_1)
queue_client = service_client.get_queue_client("foo")
self.assertEqual(queue_client.api_version, self.api_version_1)
self.assertEqual(queue_client._client._config.version,
self.api_version_1)
class StorageQueueEncryptionTestAsync(QueueTestCase):
def setUp(self):
super(StorageQueueEncryptionTestAsync, self).setUp()
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
self.qsc = QueueServiceClient(account_url=queue_url, credential=credentials)
self.test_queues = []
def tearDown(self):
loop = asyncio.get_event_loop()
if not self.is_playback():
for queue in self.test_queues:
try:
loop.run_until_complete(self.qsc.delete_queue(queue.queue_name))
except:
pass
return super(StorageQueueEncryptionTestAsync, self).tearDown()
# --Helpers-----------------------------------------------------------------
def _get_queue_reference(self, prefix=TEST_QUEUE_PREFIX):
queue_name = self.get_resource_name(prefix)
queue = self.qsc.get_queue_client(queue_name)
self.test_queues.append(queue)
return queue
async def _create_queue(self, prefix=TEST_QUEUE_PREFIX):
queue = self._get_queue_reference(prefix)
try:
created = await queue.create_queue()
except ResourceExistsError:
pass
return queue
# --------------------------------------------------------------------------
async def _test_get_messages_encrypted_kek(self):
# Arrange
self.qsc.key_encryption_key = KeyWrapper('key1')
queue = await self._create_queue()
await queue.enqueue_message(u'encrypted_message_2')
# Act
li = None
async for m in queue.receive_messages():
li = m
# Assert
self.assertEqual(li.content, u'encrypted_message_2')
def test_get_messages_encrypted_kek(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_messages_encrypted_kek())
async def _test_get_messages_encrypted_resolver(self):
# Arrange
self.qsc.key_encryption_key = KeyWrapper('key1')
queue = await self._create_queue()
await queue.enqueue_message(u'encrypted_message_2')
key_resolver = KeyResolver()
key_resolver.put_key(self.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 = None
async for m in queue.receive_messages():
li = m
# Assert
self.assertEqual(li.content, u'encrypted_message_2')
def test_get_messages_encrypted_resolver(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_messages_encrypted_resolver())
async def _test_peek_messages_encrypted_kek(self):
# Arrange
self.qsc.key_encryption_key = KeyWrapper('key1')
queue = await self._create_queue()
await queue.enqueue_message(u'encrypted_message_3')
# Act
li = await queue.peek_messages()
# Assert
self.assertEqual(li[0].content, u'encrypted_message_3')
def test_peek_messages_encrypted_kek(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_peek_messages_encrypted_kek())
async def _test_peek_messages_encrypted_resolver(self):
# Arrange
self.qsc.key_encryption_key = KeyWrapper('key1')
queue = await self._create_queue()
await queue.enqueue_message(u'encrypted_message_4')
key_resolver = KeyResolver()
key_resolver.put_key(self.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')
def test_peek_messages_encrypted_resolver(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_peek_messages_encrypted_resolver())
async def _test_peek_messages_encrypted_kek_RSA(self):
# We can only generate random RSA keys, so this must be run live or
# the playback test will fail due to a change in kek values.
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
self.qsc.key_encryption_key = RSAKeyWrapper('key2')
queue = await self._create_queue()
await queue.enqueue_message(u'encrypted_message_3')
# Act
li = await queue.peek_messages()
# Assert
self.assertEqual(li[0].content, u'encrypted_message_3')
def test_peek_messages_encrypted_kek_RSA(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_peek_messages_encrypted_kek_RSA())
async def _test_update_encrypted_message(self):
# TODO: Recording doesn't work
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue = await self._create_queue()
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)
def test_update_encrypted_message(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_update_encrypted_message())
async def _test_update_encrypted_binary_message(self):
# Arrange
queue = await self._create_queue()
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)
def test_update_encrypted_binary_message(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_update_encrypted_binary_message())
async def _test_update_encrypted_raw_text_message(self):
# TODO: Recording doesn't work
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue = await self._create_queue()
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)
def test_update_encrypted_raw_text_message(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_update_encrypted_raw_text_message())
async def _test_update_encrypted_json_message(self):
# TODO: Recording doesn't work
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue = await self._create_queue()
queue.key_encryption_key = KeyWrapper('key1')
queue._config.message_encode_policy = NoEncodePolicy()
queue._config.message_decode_policy = NoDecodePolicy()
message_dict = {'val1': 1, 'val2': '2'}
json_text = dumps(message_dict)
await queue.enqueue_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))
def test_update_encrypted_json_message(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_update_encrypted_json_message())
async def _test_invalid_value_kek_wrap(self):
# Arrange
queue = await self._create_queue()
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')
def test_invalid_value_kek_wrap(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_invalid_value_kek_wrap())
async def _test_missing_attribute_kek_wrap(self):
# Arrange
queue = await self._create_queue()
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')
def test_missing_attribute_kek_wrap(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_missing_attribute_kek_wrap())
async def _test_invalid_value_kek_unwrap(self):
# Arrange
queue = await self._create_queue()
queue.key_encryption_key = KeyWrapper('key1')
await queue.enqueue_message(u'message')
# Act
queue.key_encryption_key.unwrap_key = None
with self.assertRaises(HttpResponseError):
await queue.peek_messages()
queue.key_encryption_key.get_kid = None
with self.assertRaises(HttpResponseError):
await queue.peek_messages()
def test_invalid_value_kek_unwrap(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_invalid_value_kek_unwrap())
async def _test_missing_attribute_kek_unrwap(self):
# Arrange
queue = await self._create_queue()
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()
def test_missing_attribute_kek_unrwap(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_missing_attribute_kek_unrwap())
async def _test_validate_encryption(self):
# Arrange
queue = await self._create_queue()
kek = KeyWrapper('key1')
queue.key_encryption_key = kek
await queue.enqueue_message(u'message')
# Act
queue.key_encryption_key = None # Message will not be decrypted
li = await queue.peek_messages()
message = li[0].content
message = loads(message)
encryption_data = message['EncryptionData']
wrapped_content_key = encryption_data['WrappedContentKey']
wrapped_content_key = _WrappedContentKey(
wrapped_content_key['Algorithm'],
b64decode(wrapped_content_key['EncryptedKey'].encode(encoding='utf-8')),
wrapped_content_key['KeyId'])
encryption_agent = encryption_data['EncryptionAgent']
encryption_agent = _EncryptionAgent(
encryption_agent['EncryptionAlgorithm'],
encryption_agent['Protocol'])
encryption_data = _EncryptionData(
b64decode(encryption_data['ContentEncryptionIV'].encode(encoding='utf-8')),
encryption_agent,
wrapped_content_key,
{'EncryptionLibrary': VERSION})
message = message['EncryptedMessageContents']
content_encryption_key = kek.unwrap_key(
encryption_data.wrapped_content_key.encrypted_key,
encryption_data.wrapped_content_key.algorithm)
# Create decryption cipher
backend = backends.default_backend()
algorithm = AES(content_encryption_key)
mode = CBC(encryption_data.content_encryption_IV)
cipher = Cipher(algorithm, mode, backend)
# decode and decrypt data
decrypted_data = _decode_base64_to_bytes(message)
decryptor = cipher.decryptor()
decrypted_data = (decryptor.update(decrypted_data) + decryptor.finalize())
# unpad data
unpadder = PKCS7(128).unpadder()
decrypted_data = (unpadder.update(decrypted_data) + unpadder.finalize())
decrypted_data = decrypted_data.decode(encoding='utf-8')
# Assert
self.assertEqual(decrypted_data, u'message')
def test_validate_encryption(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_validate_encryption())
async def _test_put_with_strict_mode(self):
# Arrange
queue = await self._create_queue()
kek = KeyWrapper('key1')
queue.key_encryption_key = kek
queue.require_encryption = True
await queue.enqueue_message(u'message')
queue.key_encryption_key = None
# Assert
with self.assertRaises(ValueError) as e:
await queue.enqueue_message(u'message')
self.assertEqual(str(e.exception), "Encryption required but no key was provided.")
def test_put_with_strict_mode(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_put_with_strict_mode())
async def _test_get_with_strict_mode(self):
# Arrange
queue = await self._create_queue()
await queue.enqueue_message(u'message')
queue.require_encryption = True
queue.key_encryption_key = KeyWrapper('key1')
with self.assertRaises(ValueError) as e:
messages = []
async for m in queue.receive_messages():
messages.append(m)
_ = messages[0]
self.assertEqual(str(e.exception), 'Message was not encrypted.')
def test_get_with_strict_mode(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_with_strict_mode())
async def _test_encryption_add_encrypted_64k_message(self):
# Arrange
queue = await self._create_queue()
message = u'a' * 1024 * 64
# Act
await queue.enqueue_message(message)
# Assert
queue.key_encryption_key = KeyWrapper('key1')
with self.assertRaises(HttpResponseError):
await queue.enqueue_message(message)
def test_encryption_add_encrypted_64k_message(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_encryption_add_encrypted_64k_message())
async def _test_encryption_nonmatching_kid(self):
# Arrange
queue = await self._create_queue()
queue.key_encryption_key = KeyWrapper('key1')
await queue.enqueue_message(u'message')
# Act
queue.key_encryption_key.kid = 'Invalid'
# Assert
with self.assertRaises(HttpResponseError) as e:
messages = []
async for m in queue.receive_messages():
messages.append(m)
self.assertEqual(str(e.exception), "Decryption failed.")
def test_encryption_nonmatching_kid(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_encryption_nonmatching_kid())
class StorageQueueTestAsync(QueueTestCase):
def setUp(self):
super(StorageQueueTestAsync, self).setUp()
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
self.qsc = QueueServiceClient(account_url=queue_url,
credential=credentials,
transport=AiohttpTestTransport())
self.test_queues = []
def tearDown(self):
if not self.is_playback():
loop = asyncio.get_event_loop()
for queue in self.test_queues:
try:
loop.run_until_complete(queue.delete_queue())
except:
pass
return super(StorageQueueTestAsync, self).tearDown()
# --Helpers-----------------------------------------------------------------
def _get_queue_reference(self, prefix=TEST_QUEUE_PREFIX):
queue_name = self.get_resource_name(prefix)
queue = self.qsc.get_queue_client(queue_name)
self.test_queues.append(queue)
return queue
async def _create_queue(self, prefix=TEST_QUEUE_PREFIX):
queue = self._get_queue_reference(prefix)
created = await queue.create_queue()
return queue
# --Test cases for queues ----------------------------------------------
async def _test_create_queue(self):
# Action
queue_client = self._get_queue_reference()
created = await queue_client.create_queue()
# Asserts
self.assertTrue(created)
@record
def test_create_queue(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_create_queue())
async def _test_create_queue_fail_on_exist(self):
# Action
queue_client = self._get_queue_reference()
created = await queue_client.create_queue()
with self.assertRaises(ResourceExistsError):
await queue_client.create_queue()
# Asserts
self.assertTrue(created)
@record
def test_create_queue_fail_on_exist(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_create_queue_fail_on_exist())
async def _test_create_queue_fail_on_exist_different_metadata(self):
# Action
queue_client = self._get_queue_reference()
created = await queue_client.create_queue()
with self.assertRaises(ResourceExistsError):
await queue_client.create_queue(metadata={"val": "value"})
# Asserts
self.assertTrue(created)
@record
def test_create_queue_fail_on_exist_different_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_create_queue_fail_on_exist_different_metadata())
async def _test_create_queue_with_options(self):
# Action
queue_client = self._get_queue_reference()
await queue_client.create_queue(metadata={
'val1': 'test',
'val2': 'blah'
})
props = await queue_client.get_queue_properties()
# Asserts
self.assertEqual(0, props.approximate_message_count)
self.assertEqual(2, len(props.metadata))
self.assertEqual('test', props.metadata['val1'])
self.assertEqual('blah', props.metadata['val2'])
@record
def test_create_queue_with_options(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_create_queue_with_options())
async def _test_delete_non_existing_queue(self):
# Action
queue_client = self._get_queue_reference()
# Asserts
with self.assertRaises(ResourceNotFoundError):
await queue_client.delete_queue()
@record
def test_delete_non_existing_queue(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_delete_non_existing_queue())
async def _test_delete_existing_queue_fail_not_exist(self):
# Action
queue_client = self._get_queue_reference()
created = await queue_client.create_queue()
deleted = await queue_client.delete_queue()
# Asserts
self.assertIsNone(deleted)
@record
def test_delete_existing_queue_fail_not_exist(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_delete_existing_queue_fail_not_exist())
async def _test_list_queues(self):
# Action
queues = []
async for q in self.qsc.list_queues():
queues.append(q)
# Asserts
self.assertIsNotNone(queues)
self.assertTrue(len(self.test_queues) <= len(queues))
@record
def test_list_queues(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_queues())
async def _test_list_queues_with_options(self):
# Arrange
prefix = 'listqueue'
for i in range(0, 4):
await self._create_queue(prefix + str(i))
# Action
generator1 = self.qsc.list_queues(name_starts_with=prefix,
results_per_page=3).by_page()
queues1 = []
async for el in await generator1.__anext__():
queues1.append(el)
generator2 = self.qsc.list_queues(name_starts_with=prefix,
include_metadata=True).by_page(
generator1.continuation_token)
queues2 = []
async for el in await generator2.__anext__():
queues2.append(el)
# Asserts
self.assertIsNotNone(queues1)
self.assertEqual(3, len(queues1))
self.assertIsNotNone(queues1[0])
self.assertIsNone(queues1[0].metadata)
self.assertNotEqual('', queues1[0].name)
# Asserts
self.assertIsNotNone(queues2)
self.assertTrue(len(self.test_queues) - 3 <= len(queues2))
self.assertIsNotNone(queues2[0])
self.assertNotEqual('', queues2[0].name)
@record
def test_list_queues_with_options_async(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_queues_with_options())
async def _test_list_queues_with_metadata(self):
# Action
queue = await self._create_queue()
await queue.set_queue_metadata(metadata={
'val1': 'test',
'val2': 'blah'
})
listed_queue = []
async for q in self.qsc.list_queues(name_starts_with=queue.queue_name,
results_per_page=1,
include_metadata=True):
listed_queue.append(q)
listed_queue = listed_queue[0]
# Asserts
self.assertIsNotNone(listed_queue)
self.assertEqual(queue.queue_name, listed_queue.name)
self.assertIsNotNone(listed_queue.metadata)
self.assertEqual(len(listed_queue.metadata), 2)
self.assertEqual(listed_queue.metadata['val1'], 'test')
@record
def test_list_queues_with_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_queues_with_metadata())
async def _test_set_queue_metadata(self):
# Action
metadata = {'hello': 'world', 'number': '43'}
queue = await self._create_queue()
# Act
await queue.set_queue_metadata(metadata)
metadata_from_response = await queue.get_queue_properties()
md = metadata_from_response.metadata
# Assert
self.assertDictEqual(md, metadata)
@record
def test_set_queue_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_queue_metadata())
async def _test_get_queue_metadata_message_count(self):
# Action
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
props = await queue_client.get_queue_properties()
# Asserts
self.assertTrue(props.approximate_message_count >= 1)
self.assertEqual(0, len(props.metadata))
@record
def test_get_queue_metadata_message_count(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_queue_metadata_message_count())
async def _test_queue_exists(self):
# Arrange
queue = await self._create_queue()
# Act
exists = await queue.get_queue_properties()
# Assert
self.assertTrue(exists)
@record
def test_queue_exists(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_queue_exists())
async def _test_queue_not_exists(self):
# Arrange
queue = self.qsc.get_queue_client(self.get_resource_name('missing'))
# Act
with self.assertRaises(ResourceNotFoundError):
await queue.get_queue_properties()
# Assert
@record
def test_queue_not_exists(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_queue_not_exists())
async def _test_put_message(self):
# Action. No exception means pass. No asserts needed.
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
await queue_client.enqueue_message(u'message2')
await queue_client.enqueue_message(u'message3')
message = await queue_client.enqueue_message(u'message4')
# Asserts
self.assertIsNotNone(message)
self.assertNotEqual('', message.id)
self.assertIsInstance(message.insertion_time, datetime)
self.assertIsInstance(message.expiration_time, datetime)
self.assertNotEqual('', message.pop_receipt)
self.assertEqual(u'message4', message.content)
@record
def test_put_message(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_put_message())
async def _test_put_message_large_time_to_live(self):
# Arrange
queue_client = await self._create_queue()
# There should be no upper bound on a queue message's time to live
await queue_client.enqueue_message(u'message1',
time_to_live=1024 * 1024 * 1024)
# Act
messages = await queue_client.peek_messages()
# Assert
self.assertGreaterEqual(
messages[0].expiration_time, messages[0].insertion_time +
timedelta(seconds=1024 * 1024 * 1024 - 3600))
@record
def test_put_message_large_time_to_live(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_put_message_large_time_to_live())
async def _test_put_message_infinite_time_to_live(self):
# Arrange
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1', time_to_live=-1)
# Act
messages = await queue_client.peek_messages()
# Assert
self.assertEqual(messages[0].expiration_time.year, date.max.year)
@record
def test_put_message_infinite_time_to_live(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_put_message_infinite_time_to_live())
async def _test_get_messages(self):
# Action
queue_client = await self._create_queue()
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')
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.insertion_time, datetime)
self.assertIsInstance(message.expiration_time, datetime)
self.assertIsInstance(message.time_next_visible, datetime)
@record
def test_get_messages(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_messages())
async def _test_get_messages_with_options(self):
# Action
queue_client = await self._create_queue()
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')
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.insertion_time)
self.assertNotEqual('', message.expiration_time)
self.assertNotEqual('', message.time_next_visible)
@record
def test_get_messages_with_options(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_messages_with_options())
async def _test_peek_messages(self):
# Action
queue_client = await self._create_queue()
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()
# Asserts
self.assertIsNotNone(result)
self.assertEqual(1, len(result))
message = result[0]
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)
@record
def test_peek_messages(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_peek_messages())
async def _test_peek_messages_with_options(self):
# Action
queue_client = await self._create_queue()
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)
@record
def test_peek_messages_with_options(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_peek_messages_with_options())
async def _test_clear_messages(self):
# Action
queue_client = await self._create_queue()
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')
await queue_client.clear_messages()
result = await queue_client.peek_messages()
# Asserts
self.assertIsNotNone(result)
self.assertEqual(0, len(result))
@record
def test_clear_messages(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_clear_messages())
async def _test_delete_message(self):
# Action
queue_client = await self._create_queue()
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')
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
await queue_client.delete_message(m)
async for m in queue_client.receive_messages():
messages.append(m)
# Asserts
self.assertIsNotNone(messages)
self.assertEqual(3, len(messages) - 1)
@record
def test_delete_message(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_delete_message())
async def _test_update_message(self):
# Action
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
list_result1 = messages[0]
message = await queue_client.update_message(
list_result1.id,
pop_receipt=list_result1.pop_receipt,
visibility_timeout=0)
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
list_result2 = messages[0]
# Asserts
# Update response
self.assertIsNotNone(message)
self.assertIsNotNone(message.pop_receipt)
self.assertIsNotNone(message.time_next_visible)
self.assertIsInstance(message.time_next_visible, datetime)
# Get response
self.assertIsNotNone(list_result2)
message = list_result2
self.assertIsNotNone(message)
self.assertEqual(list_result1.id, message.id)
self.assertEqual(u'message1', message.content)
self.assertEqual(2, message.dequeue_count)
self.assertIsNotNone(message.pop_receipt)
self.assertIsNotNone(message.insertion_time)
self.assertIsNotNone(message.expiration_time)
self.assertIsNotNone(message.time_next_visible)
@record
def test_update_message(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_update_message())
async def _test_update_message_content(self):
# Action
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
list_result1 = messages[0]
message = await queue_client.update_message(
list_result1.id,
pop_receipt=list_result1.pop_receipt,
visibility_timeout=0,
content=u'new text')
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
list_result2 = messages[0]
# Asserts
# Update response
self.assertIsNotNone(message)
self.assertIsNotNone(message.pop_receipt)
self.assertIsNotNone(message.time_next_visible)
self.assertIsInstance(message.time_next_visible, datetime)
# Get response
self.assertIsNotNone(list_result2)
message = list_result2
self.assertIsNotNone(message)
self.assertEqual(list_result1.id, message.id)
self.assertEqual(u'new text', message.content)
self.assertEqual(2, message.dequeue_count)
self.assertIsNotNone(message.pop_receipt)
self.assertIsNotNone(message.insertion_time)
self.assertIsNotNone(message.expiration_time)
self.assertIsNotNone(message.time_next_visible)
@record
def test_update_message_content(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_update_message_content())
async def _test_account_sas(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
token = self.qsc.generate_shared_access_signature(
ResourceTypes.OBJECT, AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
datetime.utcnow() - timedelta(minutes=5))
# Act
service = QueueServiceClient(
account_url=self.qsc.url,
credential=token,
)
new_queue_client = service.get_queue_client(queue_client.queue_name)
result = await new_queue_client.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)
@record
def test_account_sas(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_account_sas())
async def _test_token_credential(self):
if TestMode.need_recording_file(self.test_mode):
return
token_credential = self.generate_oauth_token()
# Action 1: make sure token works
service = QueueServiceClient(self._get_oauth_queue_url(),
credential=token_credential)
queues = await service.get_service_properties()
self.assertIsNotNone(queues)
# Action 2: change token value to make request fail
fake_credential = self.generate_fake_token()
service = QueueServiceClient(self._get_oauth_queue_url(),
credential=fake_credential)
with self.assertRaises(ClientAuthenticationError):
queue_li = await service.list_queues()
list(queue_li)
# Action 3: update token to make it working again
service = QueueServiceClient(self._get_oauth_queue_url(),
credential=token_credential)
queue_li = await service.list_queues()
queues = list(queue_li)
self.assertIsNotNone(queues)
@record
def test_token_credential(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_token_credential())
async def _test_sas_read(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue_client = await self._create_queue()
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)
@record
def test_sas_read(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_sas_read())
async def _test_sas_add(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue_client = await self._create_queue()
token = queue_client.generate_shared_access_signature(
QueuePermissions.ADD,
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)
@record
def test_sas_add(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_sas_add())
async def _test_sas_update(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1')
token = queue_client.generate_shared_access_signature(
QueuePermissions.UPDATE,
datetime.utcnow() + timedelta(hours=1),
)
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
result = messages[0]
# Act
service = QueueClient(
queue_url=queue_client.url,
credential=token,
)
await service.update_message(
result.id,
pop_receipt=result.pop_receipt,
visibility_timeout=0,
content=u'updatedmessage1',
)
# Assert
messages = []
async for m in queue_client.receive_messages():
messages.append(m)
result = messages[0]
self.assertEqual(u'updatedmessage1', result.content)
@record
def test_sas_update(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_sas_update())
async def _test_sas_process(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
queue_client = await self._create_queue()
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)
@record
def test_sas_process(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_sas_process())
async def _test_sas_signed_identifier(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
access_policy = AccessPolicy()
access_policy.start = datetime.utcnow() - timedelta(hours=1)
access_policy.expiry = datetime.utcnow() + timedelta(hours=1)
access_policy.permission = QueuePermissions.READ
identifiers = {'testid': access_policy}
queue_client = await self._create_queue()
resp = await queue_client.set_queue_access_policy(identifiers)
await queue_client.enqueue_message(u'message1')
token = queue_client.generate_shared_access_signature(
policy_id='testid')
# 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)
@record
def test_sas_signed_identifier(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_sas_signed_identifier())
async def _test_get_queue_acl(self):
# Arrange
queue_client = await self._create_queue()
# Act
acl = await queue_client.get_queue_access_policy()
# Assert
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 0)
@record
def test_get_queue_acl(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_queue_acl())
async def _test_get_queue_acl_iter(self):
# Arrange
queue_client = await self._create_queue()
# Act
acl = await queue_client.get_queue_access_policy()
for signed_identifier in acl:
pass
# Assert
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 0)
@record
def test_get_queue_acl_iter(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_queue_acl_iter())
async def _test_get_queue_acl_with_non_existing_queue(self):
# Arrange
queue_client = self._get_queue_reference()
# Act
with self.assertRaises(ResourceNotFoundError):
await queue_client.get_queue_access_policy()
# Assert
@record
def test_get_queue_acl_with_non_existing_queue(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_get_queue_acl_with_non_existing_queue())
async def _test_set_queue_acl(self):
# Arrange
queue_client = await self._create_queue()
# Act
resp = await queue_client.set_queue_access_policy()
# Assert
self.assertIsNone(resp)
acl = await queue_client.get_queue_access_policy()
self.assertIsNotNone(acl)
@record
def test_set_queue_acl(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_queue_acl())
async def _test_set_queue_acl_with_empty_signed_identifiers(self):
# Arrange
queue_client = await self._create_queue()
# Act
await queue_client.set_queue_access_policy(signed_identifiers={})
# Assert
acl = await queue_client.get_queue_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 0)
@record
def test_set_queue_acl_with_empty_signed_identifiers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_queue_acl_with_empty_signed_identifiers())
async def _test_set_queue_acl_with_empty_signed_identifier(self):
# Arrange
queue_client = await self._create_queue()
# Act
await queue_client.set_queue_access_policy(
signed_identifiers={'empty': AccessPolicy()})
# Assert
acl = await queue_client.get_queue_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 1)
self.assertIsNotNone(acl['empty'])
self.assertIsNone(acl['empty'].permission)
self.assertIsNone(acl['empty'].expiry)
self.assertIsNone(acl['empty'].start)
@record
def test_set_queue_acl_with_empty_signed_identifier(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_queue_acl_with_empty_signed_identifier())
async def _test_set_queue_acl_with_signed_identifiers(self):
# Arrange
queue_client = await self._create_queue()
# 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)
@record
def test_set_queue_acl_with_signed_identifiers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_queue_acl_with_signed_identifiers())
async def _test_set_queue_acl_too_many_ids(self):
# Arrange
queue_client = await self._create_queue()
# Act
identifiers = dict()
for i in range(0, 16):
identifiers['id{}'.format(i)] = AccessPolicy()
# Assert
with self.assertRaises(ValueError):
await queue_client.set_queue_access_policy(identifiers)
@record
def test_set_queue_acl_too_many_ids(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_queue_acl_too_many_ids())
async def _test_set_queue_acl_with_non_existing_queue(self):
# Arrange
queue_client = self._get_queue_reference()
# Act
with self.assertRaises(ResourceNotFoundError):
await queue_client.set_queue_access_policy()
@record
def test_set_queue_acl_with_non_existing_queue(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_queue_acl_with_non_existing_queue())
async def _test_unicode_create_queue_unicode_name(self):
# Action
queue_name = u'啊齄丂狛狜'
with self.assertRaises(HttpResponseError):
# not supported - queue name must be alphanumeric, lowercase
client = self.qsc.get_queue_client(queue_name)
await client.create_queue()
# Asserts
@record
def test_unicode_create_queue_unicode_name(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_unicode_create_queue_unicode_name())
async def _test_unicode_get_messages_unicode_data(self):
# Action
queue_client = await self._create_queue()
await queue_client.enqueue_message(u'message1㚈')
message = None
async for m in queue_client.receive_messages():
message = m
# Asserts
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.insertion_time, datetime)
self.assertIsInstance(message.expiration_time, datetime)
self.assertIsInstance(message.time_next_visible, datetime)
@record
def test_unicode_get_messages_unicode_data(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_unicode_get_messages_unicode_data())
async def _test_unicode_update_message_unicode_data(self):
# Action
queue_client = await self._create_queue()
await queue_client.enqueue_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.insertion_time, datetime)
self.assertIsInstance(message.expiration_time, datetime)
self.assertIsInstance(message.time_next_visible, datetime)
@record
def test_unicode_update_message_unicode_data(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_unicode_update_message_unicode_data())
class StorageQueueEncodingTestAsync(QueueTestCase):
def setUp(self):
super(StorageQueueEncodingTestAsync, self).setUp()
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
self.qsc = QueueServiceClient(account_url=queue_url,
credential=credentials,
transport=AiohttpTestTransport())
self.test_queues = []
def tearDown(self):
if not self.is_playback():
loop = asyncio.get_event_loop()
for queue in self.test_queues:
try:
loop.run_until_complete(
self.qsc.delete_queue(queue.queue_name))
except:
pass
return super(StorageQueueEncodingTestAsync, self).tearDown()
# --Helpers-----------------------------------------------------------------
def _get_queue_reference(self, prefix=TEST_QUEUE_PREFIX):
queue_name = self.get_resource_name(prefix)
queue = self.qsc.get_queue_client(queue_name)
self.test_queues.append(queue)
return queue
async def _create_queue(self, prefix=TEST_QUEUE_PREFIX):
queue = self._get_queue_reference(prefix)
try:
created = await queue.create_queue()
except ResourceExistsError:
pass
return queue
async def _validate_encoding(self, queue, message):
# Arrange
try:
created = await queue.create_queue()
except ResourceExistsError:
pass
# Action.
await queue.enqueue_message(message)
# Asserts
dequeued = None
async for m in queue.receive_messages():
dequeued = m
self.assertEqual(message, dequeued.content)
# --------------------------------------------------------------------------
async def _test_message_text_xml(self):
# Arrange.
message = u'<message1>'
queue = self.qsc.get_queue_client(
self.get_resource_name(TEST_QUEUE_PREFIX))
# Asserts
await self._validate_encoding(queue, message)
@record
def test_message_text_xml(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_text_xml())
async def _test_message_text_xml_whitespace(self):
# Arrange.
message = u' mess\t age1\n'
queue = self.qsc.get_queue_client(
self.get_resource_name(TEST_QUEUE_PREFIX))
# Asserts
await self._validate_encoding(queue, message)
@record
def test_message_text_xml_whitespace(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_text_xml_whitespace())
async def _test_message_text_xml_invalid_chars(self):
# Action.
queue = self._get_queue_reference()
message = u'\u0001'
# Asserts
with self.assertRaises(HttpResponseError):
await queue.enqueue_message(message)
@record
def test_message_text_xml_invalid_chars(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_text_xml_invalid_chars())
async def _test_message_text_base64(self):
# Arrange.
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
queue = QueueClient(queue_url=queue_url,
queue=self.get_resource_name(TEST_QUEUE_PREFIX),
credential=credentials,
message_encode_policy=TextBase64EncodePolicy(),
message_decode_policy=TextBase64DecodePolicy(),
transport=AiohttpTestTransport())
message = '\u0001'
# Asserts
await self._validate_encoding(queue, message)
@record
def test_message_text_base64(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_text_base64())
async def _test_message_bytes_base64(self):
# Arrange.
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
queue = QueueClient(queue_url=queue_url,
queue=self.get_resource_name(TEST_QUEUE_PREFIX),
credential=credentials,
message_encode_policy=BinaryBase64EncodePolicy(),
message_decode_policy=BinaryBase64DecodePolicy(),
transport=AiohttpTestTransport())
message = b'xyz'
# Asserts
await self._validate_encoding(queue, message)
@record
def test_message_bytes_base64(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_bytes_base64())
async def _test_message_bytes_fails(self):
# Arrange
queue = self._get_queue_reference()
# Action.
with self.assertRaises(TypeError) as e:
message = b'xyz'
await queue.enqueue_message(message)
# Asserts
self.assertTrue(
str(e.exception).startswith('Message content must be text'))
@record
def test_message_bytes_fails(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_bytes_fails())
async def _test_message_text_fails(self):
# Arrange
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
queue = QueueClient(queue_url=queue_url,
queue=self.get_resource_name(TEST_QUEUE_PREFIX),
credential=credentials,
message_encode_policy=BinaryBase64EncodePolicy(),
message_decode_policy=BinaryBase64DecodePolicy(),
transport=AiohttpTestTransport())
# Action.
with self.assertRaises(TypeError) as e:
message = u'xyz'
await queue.enqueue_message(message)
# Asserts
self.assertTrue(
str(e.exception).startswith('Message content must be bytes'))
@record
def test_message_text_fails(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_text_fails())
async def _test_message_base64_decode_fails(self):
# Arrange
queue_url = self._get_queue_url()
credentials = self._get_shared_key_credential()
queue = QueueClient(queue_url=queue_url,
queue=self.get_resource_name(TEST_QUEUE_PREFIX),
credential=credentials,
message_encode_policy=TextXMLEncodePolicy(),
message_decode_policy=BinaryBase64DecodePolicy(),
transport=AiohttpTestTransport())
try:
await queue.create_queue()
except ResourceExistsError:
pass
message = u'xyz'
await queue.enqueue_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'))
@record
def test_message_base64_decode_fails(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_message_base64_decode_fails())
