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), credential=storage_account_key, user_agent=custom_app) 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())) 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())) service.get_service_properties(raw_response_hook=callback, user_agent="TestApp/v2.0")
def test_user_agent_default(self, resource_group, location, storage_account, storage_account_key): service = QueueServiceClient(self.account_url(storage_account, "queue"), credential=storage_account_key) 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'] service.get_service_properties(raw_response_hook=callback)
def test_user_agent_append(self, resource_group, location, storage_account, storage_account_key): service = QueueServiceClient(self.account_url(storage_account, "queue"), credential=storage_account_key) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) assert ("customer_user_agent azsdk-python-storage-queue/{} Python/{} ({})".format( VERSION, platform.python_version(), platform.platform())) in response.http_request.headers['User-Agent'] service.get_service_properties(raw_response_hook=callback, user_agent='customer_user_agent')
def test_user_agent_default(self): service = QueueServiceClient(self._get_queue_url(), credential=self.account_key) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) self.assertEqual( response.http_request.headers['User-Agent'], "azsdk-python-storage-queue/{} Python/{} ({})".format( VERSION, platform.python_version(), platform.platform())) service.get_service_properties(raw_response_hook=callback)
def test_user_agent_append(self): service = QueueServiceClient(self._get_queue_url(), credential=self.account_key) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) self.assertEqual( response.http_request.headers['User-Agent'], "azsdk-python-storage-queue/12.0.0b1 Python/{} ({}) customer_user_agent" .format(platform.python_version(), platform.platform())) custom_headers = {'User-Agent': 'customer_user_agent'} service.get_service_properties(raw_response_hook=callback, headers=custom_headers)
def test_token_credential(self, resource_group, location, storage_account, storage_account_key): token_credential = self.generate_oauth_token() # Action 1: make sure token works service = QueueServiceClient(self.account_url(storage_account, "queue"), credential=token_credential) queues = 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.account_url(storage_account, "queue"), credential=fake_credential) with self.assertRaises(ClientAuthenticationError): list(service.list_queues()) # Action 3: update token to make it working again service = QueueServiceClient(self.account_url(storage_account, "queue"), credential=token_credential) queues = list(service.list_queues()) self.assertIsNotNone(queues)
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) 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 qsc.set_service_properties(cors=cors) # Assert received_props = qsc.get_service_properties() self._assert_cors_equal(received_props['cors'], cors)
def auth_shared_key(self): # Instantiate a QueueServiceClient using a shared access key # [START create_queue_service_client] from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient(account_url=self.account_url, credential=self.access_key) # [END create_queue_service_client] # Get information for the Queue Service properties = queue_service.get_service_properties()
def test_set_logging(self, resource_group, location, storage_account, storage_account_key): # Arrange qsc = QueueServiceClient(self._account_url(storage_account.name), storage_account_key) logging = Logging(read=True, write=True, delete=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act qsc.set_service_properties(logging=logging) # Assert received_props = qsc.get_service_properties() self._assert_logging_equal(received_props.logging, logging)
def test_set_logging(self, storage_account_name, storage_account_key): # Arrange qsc = QueueServiceClient(self.account_url(storage_account_name, "queue"), storage_account_key) logging = QueueAnalyticsLogging(read=True, write=True, delete=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act qsc.set_service_properties(analytics_logging=logging) # Assert received_props = qsc.get_service_properties() self._assert_logging_equal(received_props['analytics_logging'], logging)
def test_set_hour_metrics(self, storage_account_name, storage_account_key): # Arrange qsc = QueueServiceClient(self.account_url(storage_account_name, "queue"), storage_account_key) hour_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act qsc.set_service_properties(hour_metrics=hour_metrics) # Assert received_props = qsc.get_service_properties() self._assert_metrics_equal(received_props['hour_metrics'], hour_metrics)
def test_set_minute_metrics(self, resource_group, location, storage_account, storage_account_key): # Arrange qsc = QueueServiceClient(self._account_url(storage_account.name), storage_account_key) minute_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act qsc.set_service_properties(minute_metrics=minute_metrics) # Assert received_props = qsc.get_service_properties() self._assert_metrics_equal(received_props.minute_metrics, minute_metrics)
def test_auth_shared_key(self, resource_group, location, storage_account, storage_account_key): # Instantiate a QueueServiceClient using a shared access key # [START create_queue_service_client] from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient( self._account_url(storage_account.name), storage_account_key) # [END create_queue_service_client] # Get information for the Queue Service properties = queue_service.get_service_properties() assert properties is not None
def test_auth_connection_string(self, resource_group, location, storage_account, storage_account_key): # Instantiate a QueueServiceClient using a connection string # [START auth_from_connection_string] from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient( self._account_url(storage_account.name), storage_account_key) # [END auth_from_connection_string] # Get information for the Queue Service properties = queue_service.get_service_properties() assert properties is not None
def test_queue_service_properties(self, resource_group, location, storage_account, storage_account_key): # Arrange qsc = QueueServiceClient(self._account_url(storage_account.name), storage_account_key) # Act resp = qsc.set_service_properties( logging=Logging(), hour_metrics=Metrics(), minute_metrics=Metrics(), cors=list()) # Assert self.assertIsNone(resp) self._assert_properties_default(qsc.get_service_properties())
def test_queue_service_properties(self, storage_account_name, storage_account_key): # Arrange qsc = QueueServiceClient(self.account_url(storage_account_name, "queue"), storage_account_key) # Act resp = qsc.set_service_properties( analytics_logging=QueueAnalyticsLogging(), hour_metrics=Metrics(), minute_metrics=Metrics(), cors=list()) # Assert self.assertIsNone(resp) self._assert_properties_default(qsc.get_service_properties())
def test_user_agent_custom(self): custom_app = "TestApp/v1.0" service = QueueServiceClient(self._get_queue_url(), credential=self.account_key, user_agent=custom_app) 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/12.0.0b1 Python/{} ({})" .format(platform.python_version(), platform.platform())) 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/12.0.0b1 Python/{} ({})" .format(platform.python_version(), platform.platform())) service.get_service_properties(raw_response_hook=callback, user_agent="TestApp/v2.0")
def auth_active_directory(self): # [START create_queue_service_client_token] # Get a token credential for authentication from azure.identity import ClientSecretCredential token_credential = ClientSecretCredential( self.active_directory_tenant_id, self.active_directory_application_id, self.active_directory_application_secret) # Instantiate a QueueServiceClient using a token credential from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient(account_url=self.account_url, credential=token_credential) # [END create_queue_service_client_token] # Get information for the Queue Service properties = queue_service.get_service_properties()
def test_auth_active_directory(self): pytest.skip('pending azure identity') # Get a token credential for authentication from azure.identity import ClientSecretCredential token_credential = ClientSecretCredential( self.active_directory_application_id, self.active_directory_application_secret, self.active_directory_tenant_id ) # Instantiate a QueueServiceClient using a token credential from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient(account_url=self.url, credential=token_credential) # Get information for the Queue Service properties = queue_service.get_service_properties() assert properties is not None
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 = 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): list(service.list_queues()) # Action 3: update token to make it working again service = QueueServiceClient(self._get_oauth_queue_url(), credential=token_credential) queues = list(service.list_queues()) self.assertIsNotNone(queues)
def auth_shared_access_signature(self): # Instantiate a QueueServiceClient using a connection string from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient.from_connection_string( conn_str=self.connection_string) # Create a SAS token to use for authentication of a client from azure.storage.queue import generate_account_sas sas_token = generate_account_sas(queue_service.account_name, queue_service.credential.account_key, resource_types="object", permission="read", expiry=datetime.utcnow() + timedelta(hours=1)) token_auth_queue_service = QueueServiceClient( account_url=self.account_url, credential=sas_token) # Get information for the Queue Service properties = token_auth_queue_service.get_service_properties()
def test_auth_active_directory(self): if TestMode.need_recording_file(self.test_mode): return # [START create_queue_service_client_token] # Get a token credential for authentication from azure.identity import ClientSecretCredential token_credential = ClientSecretCredential( self.active_directory_application_id, self.active_directory_application_secret, self.active_directory_tenant_id) # Instantiate a QueueServiceClient using a token credential from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient(account_url=self.url, credential=token_credential) # [END create_queue_service_client_token] # Get information for the Queue Service properties = queue_service.get_service_properties() assert properties is not None
def test_auth_active_directory(self, resource_group, location, storage_account, storage_account_key): if not self.is_live: return url = self._account_url(storage_account.name) # [START create_queue_service_client_token] # Get a token credential for authentication from azure.identity import ClientSecretCredential token_credential = ClientSecretCredential( self.active_directory_tenant_id, self.active_directory_application_id, self.active_directory_application_secret) # Instantiate a QueueServiceClient using a token credential from azure.storage.queue import QueueServiceClient queue_service = QueueServiceClient(account_url=url, credential=token_credential) # [END create_queue_service_client_token] # Get information for the Queue Service properties = queue_service.get_service_properties() assert properties is not None
class QueueServicePropertiesTest(QueueTestCase): def setUp(self): super(QueueServicePropertiesTest, self).setUp() url = self._get_queue_url() credential = self._get_shared_key_credential() self.qsc = QueueServiceClient(url, credential=credential) # --Helpers----------------------------------------------------------------- def _assert_properties_default(self, prop): self.assertIsNotNone(prop) self._assert_logging_equal(prop.logging, Logging()) self._assert_metrics_equal(prop.hour_metrics, Metrics()) self._assert_metrics_equal(prop.minute_metrics, Metrics()) self._assert_cors_equal(prop.cors, list()) def _assert_logging_equal(self, log1, log2): if log1 is None or log2 is None: self.assertEqual(log1, log2) return self.assertEqual(log1.version, log2.version) self.assertEqual(log1.read, log2.read) self.assertEqual(log1.write, log2.write) self.assertEqual(log1.delete, log2.delete) self._assert_retention_equal(log1.retention_policy, log2.retention_policy) def _assert_delete_retention_policy_equal(self, policy1, policy2): if policy1 is None or policy2 is None: self.assertEqual(policy1, policy2) return self.assertEqual(policy1.enabled, policy2.enabled) self.assertEqual(policy1.days, policy2.days) def _assert_static_website_equal(self, prop1, prop2): if prop1 is None or prop2 is None: self.assertEqual(prop1, prop2) return self.assertEqual(prop1.enabled, prop2.enabled) self.assertEqual(prop1.index_document, prop2.index_document) self.assertEqual(prop1.error_document404_path, prop2.error_document404_path) def _assert_delete_retention_policy_not_equal(self, policy1, policy2): if policy1 is None or policy2 is None: self.assertNotEqual(policy1, policy2) return self.assertFalse(policy1.enabled == policy2.enabled and policy1.days == policy2.days) def _assert_metrics_equal(self, metrics1, metrics2): if metrics1 is None or metrics2 is None: self.assertEqual(metrics1, metrics2) return self.assertEqual(metrics1.version, metrics2.version) self.assertEqual(metrics1.enabled, metrics2.enabled) self.assertEqual(metrics1.include_apis, metrics2.include_apis) self._assert_retention_equal(metrics1.retention_policy, metrics2.retention_policy) def _assert_cors_equal(self, cors1, cors2): if cors1 is None or cors2 is None: self.assertEqual(cors1, cors2) return self.assertEqual(len(cors1), len(cors2)) for i in range(0, len(cors1)): rule1 = cors1[i] rule2 = cors2[i] self.assertEqual(len(rule1.allowed_origins), len(rule2.allowed_origins)) self.assertEqual(len(rule1.allowed_methods), len(rule2.allowed_methods)) self.assertEqual(rule1.max_age_in_seconds, rule2.max_age_in_seconds) self.assertEqual(len(rule1.exposed_headers), len(rule2.exposed_headers)) self.assertEqual(len(rule1.allowed_headers), len(rule2.allowed_headers)) def _assert_retention_equal(self, ret1, ret2): self.assertEqual(ret1.enabled, ret2.enabled) self.assertEqual(ret1.days, ret2.days) # --Test cases per service --------------------------------------- @record def test_queue_service_properties(self): # Arrange # Act resp = self.qsc.set_service_properties( logging=Logging(), hour_metrics=Metrics(), minute_metrics=Metrics(), cors=list()) # Assert self.assertIsNone(resp) self._assert_properties_default(self.qsc.get_service_properties()) # --Test cases per feature --------------------------------------- @record def test_set_logging(self): # Arrange logging = Logging(read=True, write=True, delete=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act self.qsc.set_service_properties(logging=logging) # Assert received_props = self.qsc.get_service_properties() self._assert_logging_equal(received_props.logging, logging) @record def test_set_hour_metrics(self): # Arrange hour_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act self.qsc.set_service_properties(hour_metrics=hour_metrics) # Assert received_props = self.qsc.get_service_properties() self._assert_metrics_equal(received_props.hour_metrics, hour_metrics) @record def test_set_minute_metrics(self): # Arrange minute_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Act self.qsc.set_service_properties(minute_metrics=minute_metrics) # Assert received_props = self.qsc.get_service_properties() self._assert_metrics_equal(received_props.minute_metrics, minute_metrics) @record def test_set_cors(self): # Arrange 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 self.qsc.set_service_properties(cors=cors) # Assert received_props = self.qsc.get_service_properties() self._assert_cors_equal(received_props.cors, cors) # --Test cases for errors --------------------------------------- @record def test_retention_no_days(self): # Assert self.assertRaises(ValueError, RetentionPolicy, True, None) @record def test_too_many_cors_rules(self): # Arrange cors = [] for i in range(0, 6): cors.append(CorsRule(['www.xyz.com'], ['GET'])) # Assert self.assertRaises(HttpResponseError, self.qsc.set_service_properties, None, None, None, cors) @record def test_retention_too_long(self): # Arrange minute_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=366)) # Assert self.assertRaises(HttpResponseError, self.qsc.set_service_properties, None, None, minute_metrics)