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)