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)
