def test_get_queue_client_expired_token(self):
"""
Exception handler should deal with a bad token by clearing
cache and retrying. So if we provide a bad token followed
by a real one in our mock, we expect it to end up getting
the real token.
"""
real_token = StorageUtilities.get_storage_token(self.session)
with patch('c7n_azure.storage_utils.QueueService.create_queue'
) as create_mock:
with patch(
'c7n_azure.storage_utils.StorageUtilities.get_storage_token'
) as token_mock:
error = AzureHttpError('', 403)
error.error_code = 'AuthenticationFailed'
# Two side effects: one with a bad token and an error,
# and one with a good token and no error
create_mock.side_effect = [error, None]
token_mock.side_effect = [TokenCredential('fake'), real_token]
url = "https://fake.queue.core.windows.net/testcc"
queue_service, queue_name = \
StorageUtilities.get_queue_client_by_uri(url, self.session)
# We end up with the real token (after a retry)
self.assertEqual(real_token, queue_service.authentication)
def test_disable_retention_log_settings(self):
p = self.load_policy({
'name': 'test-azure-storage',
'resource': 'azure.storage',
'filters': [
{'type': 'value',
'key': 'name',
'op': 'glob',
'value_type': 'normalize',
'value': 'cclgstorage*'}],
'actions': [
{
'type': 'set-log-settings',
'storage-types': ['blob', 'queue', 'table'],
'retention': 0,
'log': ['read', 'write', 'delete']
}
]
}, validate=True)
resources = p.run()
session = local_session(p.session_factory)
token = StorageUtilities.get_storage_token(session)
blob_settings = StorageSettingsUtilities.get_settings(
BLOB_TYPE, resources[0], token=token)
queue_settings = StorageSettingsUtilities.get_settings(
QUEUE_TYPE, resources[0], token=token)
table_settings = StorageSettingsUtilities.get_settings(
TABLE_TYPE, resources[0], session=session)
# assert retention policy is disabled
self.assertFalse(blob_settings.logging.retention_policy.enabled)
self.assertFalse(queue_settings.logging.retention_policy.enabled)
self.assertFalse(table_settings.logging.retention_policy.enabled)
def test_enable_log_settings(self):
p = self.load_policy(
{
'name':
'test-azure-storage',
'resource':
'azure.storage',
'filters': [{
'type': 'value',
'key': 'name',
'op': 'glob',
'value_type': 'normalize',
'value': 'cclgstorage*'
}],
'actions': [{
'type': 'set-log-settings',
'storage-types': ['blob', 'queue', 'table'],
'retention': 5,
'log': ['read', 'write', 'delete']
}]
},
validate=True)
resources = p.run()
self.sleep_in_live_mode(30)
session = local_session(p.session_factory)
token = StorageUtilities.get_storage_token(session)
blob_settings = StorageSettingsUtilities.get_settings(BLOB_TYPE,
resources[0],
token=token)
queue_settings = StorageSettingsUtilities.get_settings(QUEUE_TYPE,
resources[0],
token=token)
table_settings = StorageSettingsUtilities.get_settings(TABLE_TYPE,
resources[0],
session=session)
# assert all logging settings are enabled
self.assertTrue(blob_settings.logging.delete
and blob_settings.logging.read
and blob_settings.logging.write)
self.assertTrue(queue_settings.logging.delete
and queue_settings.logging.read
and queue_settings.logging.write)
self.assertTrue(table_settings.logging.delete
and table_settings.logging.read
and table_settings.logging.write)
# assert retention policy is enabled
self.assertTrue(blob_settings.logging.retention_policy.enabled)
self.assertTrue(queue_settings.logging.retention_policy.enabled)
self.assertTrue(table_settings.logging.retention_policy.enabled)
# assert retention days is set to 5
self.assertEqual(blob_settings.logging.retention_policy.days, 5)
self.assertEqual(table_settings.logging.retention_policy.days, 5)
self.assertEqual(queue_settings.logging.retention_policy.days, 5)
def process(self, resources, event=None):
session = local_session(self.manager.session_factory)
token = StorageUtilities.get_storage_token(session)
result, errors = ThreadHelper.execute_in_parallel(
resources=resources,
event=event,
execution_method=self.process_resource_set,
executor_factory=self.executor_factory,
log=self.log,
session=session,
token=token)
return result
def test_get_storage_token(self):
token = StorageUtilities.get_storage_token(self.session)
self.assertIsNotNone(token.token)
def test_get_storage_token(self):
token = StorageUtilities.get_storage_token(self.session)
self.assertIsNotNone(token.token)
def process_in_parallel(self, resources, event):
self.token = StorageUtilities.get_storage_token(self.session)
return super(SetLogSettingsAction,
self).process_in_parallel(resources, event)
