def test_process_request_calls_fail_json_when_create_deployment_raises_exception(
self):
self.deployment.module.params = {
'name': 'tested_thing',
'rest_api_id': '12345',
'cache_cluster_enabled': False,
}
self.deployment.client.create_deployment = mock.MagicMock(
side_effect=BotoCoreError())
self.deployment.process_request()
self.deployment.client.create_deployment.assert_called_once_with(
restApiId='12345',
stageName='tested_thing',
stageDescription='',
description='',
cacheClusterEnabled=False,
)
self.deployment.module.fail_json.assert_called_once_with(
msg=
'Error while creating deployment via boto3: An unspecified error occurred'
)
def test_deletion_error(self):
'''Raises DeleteException on key.delete() error'''
key = self.bucket.Object('key')
error = BotoCoreError()
with mock.patch.object(key, 'delete', side_effect=error):
with self.assertRaises(DeleteException):
self.backend.delete('bucket', 'key', 1)
def test_process_request_calls_fail_json_when_delete_resource_fails(
self, mock_build_dict):
self.resource.path_map = {
'paths': {
'/': {
'id': 'root'
},
'/resource1': {
'id': 'abc',
'parentId': 'root'
}
}
}
self.resource.client.delete_resource = mock.MagicMock(
side_effect=BotoCoreError())
self.resource.module.params = {
'name': '/resource1',
'rest_api_id': 'mock',
'state': 'absent'
}
self.resource.process_request()
self.resource.client.delete_resource.assert_called_once_with(
restApiId='mock', resourceId='abc')
self.resource.module.fail_json.assert_called_once_with(
msg=
'Error calling boto3 delete_resource: An unspecified error occurred'
)
async def test_fetch_messages_with_botocoreerror(mock_boto_session_sqs,
boto_client_sqs):
with mock_boto_session_sqs:
error = BotoCoreError()
boto_client_sqs.receive_message.side_effect = error
provider = SQSProvider('queue-name')
with pytest.raises(ProviderError):
await provider.fetch_messages()
def test_process_request_calls_fail_json_when_get_authorizers_raises_exception(self):
self.authorizer.client.get_authorizers = mock.MagicMock(side_effect=BotoCoreError())
self.authorizer.process_request()
self.authorizer.client.get_authorizers.assert_called_once_with(restApiId='rest_id')
self.authorizer.module.fail_json.assert_called_once_with(
msg='Error when getting authorizers from boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_get_base_path_mappings_raises_exception(self):
self.bpm.client.get_base_path_mappings = mock.MagicMock(side_effect=BotoCoreError())
self.bpm.process_request()
self.bpm.client.get_base_path_mappings.assert_called_once_with(domainName='testify')
self.bpm.module.fail_json.assert_called_once_with(
msg='Error when getting base_path_mappings from boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_get_resources_fails(
self, mock_create):
self.resource.client.get_resources = mock.MagicMock(
side_effect=BotoCoreError())
self.resource.process_request()
self.resource.module.fail_json.assert_called_once_with(
msg=
"Error calling boto3 get_resources: An unspecified error occurred")
def test_process_request_calls_fail_json_when_get_usage_plan_keys_raises_exception(self):
self.usage_plan_key.client.get_usage_plan_keys = mock.MagicMock(side_effect=BotoCoreError())
self.usage_plan_key.process_request()
self.usage_plan_key.client.get_usage_plan_keys.assert_called_once_with(usagePlanId='upid')
self.usage_plan_key.module.fail_json.assert_called_once_with(
msg='Error when getting usage_plan_keys from boto3: An unspecified error occurred'
)
def test_process_request_fails_when_get_rest_apis_returns_error(self):
self.restapi.module.params = {'name': 'whatever'}
self.restapi.client.get_rest_apis = mock.MagicMock(
side_effect=BotoCoreError())
self.restapi.process_request()
self.restapi.module.fail_json.assert_called_once_with(
msg=
'Encountered fatal error calling boto3 get_rest_apis function: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_update_authorizer_raises_exception(self, m, mcp):
self.authorizer.client.update_authorizer = mock.MagicMock(side_effect=BotoCoreError())
self.authorizer.process_request()
self.authorizer.client.update_authorizer.assert_called_once_with(
restApiId='rest_id',
authorizerId='hi',
patchOperations=['patches!']
)
self.authorizer.module.fail_json.assert_called_once_with(
msg='Error when updating authorizer via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_update_api_key_raises_exception(
self, m, mcp):
self.api_key.client.update_api_key = mock.MagicMock(
side_effect=BotoCoreError())
self.api_key.process_request()
self.api_key.client.update_api_key.assert_called_once_with(
apiKey='hi', patchOperations=['patches!'])
self.api_key.module.fail_json.assert_called_once_with(
msg=
'Error when updating api_key via boto3: An unspecified error occurred'
)
def test_too_large_request(dynamodb, test_table):
p = 'abc'
c = 'def'
big = 'x' * (16 * 1024 * 1024 + 7)
# The exception type differs due to differences between HTTP servers
# in alternator and DynamoDB. The former returns 413, the latter
# a ClientError explaining that the element size was too large.
with pytest.raises(BotoCoreError):
try:
test_table.put_item(Item={'p': p, 'c': c, 'big': big})
except ClientError:
raise BotoCoreError()
def test_process_request_calls_fail_json_when_update_usage_plan_raises_exception(
self, m, mcp):
self.usage_plan.client.update_usage_plan = mock.MagicMock(
side_effect=BotoCoreError())
self.usage_plan.process_request()
self.usage_plan.client.update_usage_plan.assert_called_once_with(
usagePlanId='hi', patchOperations=['patches!'])
self.usage_plan.module.fail_json.assert_called_once_with(
msg=
'Error when updating usage_plan via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_update_base_path_mapping_raises_exception(self, m, mcp):
self.bpm.client.update_base_path_mapping = mock.MagicMock(side_effect=BotoCoreError())
self.bpm.process_request()
self.bpm.client.update_base_path_mapping.assert_called_once_with(
domainName='testify',
basePath='test_base_path',
patchOperations=['patches!']
)
self.bpm.module.fail_json.assert_called_once_with(
msg='Error when updating base_path_mapping via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_create_usage_plan_key_raises_exception(self, m):
self.usage_plan_key.client.create_usage_plan_key = mock.MagicMock(side_effect=BotoCoreError())
self.usage_plan_key.process_request()
self.usage_plan_key.client.create_usage_plan_key.assert_called_once_with(
usagePlanId='upid',
keyId='akid',
keyType='API_KEY'
)
self.usage_plan_key.module.fail_json.assert_called_once_with(
msg='Error when creating usage_plan_key via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_get_api_keys_raises_exception(
self):
self.api_key.client.get_api_keys = mock.MagicMock(
side_effect=BotoCoreError())
self.api_key.process_request()
self.api_key.client.get_api_keys.assert_called_once_with(
nameQuery='testify', includeValues=True)
self.api_key.module.fail_json.assert_called_once_with(
msg=
'Error when getting api_keys from boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_create_base_path_mapping_raises_exception(self, m):
self.bpm.client.create_base_path_mapping = mock.MagicMock(side_effect=BotoCoreError())
self.bpm.process_request()
self.bpm.client.create_base_path_mapping.assert_called_once_with(
domainName='testify',
restApiId='rest_id',
basePath='test_base_path',
stage='test_stage'
)
self.bpm.module.fail_json.assert_called_once_with(
msg='Error when creating base_path_mapping via boto3: An unspecified error occurred'
)
def test_process_request_fails_when_create_rest_api_throws_error(self):
self.restapi.module.params = {'name': 'whatever', 'state': 'present'}
self.restapi.client.get_rest_apis = mock.MagicMock(
return_value={'items': []})
self.restapi.client.create_rest_api = mock.MagicMock(
side_effect=BotoCoreError())
self.restapi.process_request()
self.restapi.client.create_rest_api.assert_called_once_with(
name='whatever')
self.restapi.module.fail_json.assert_called_once_with(
msg=
'Encountered fatal error calling boto3 create_rest_api function: An unspecified error occurred'
)
def test_get_s3_object_not_found(s3man_client_mock):
"""
Test exception when file not exists in S3 for get_s3_object function.
"""
s3man_client_mock.get_object.side_effect = BotoCoreError()
s3_file = None
with pytest.raises(HTTPException) as exc:
s3_file = get_s3_object_as_tarfile(1)
assert "Application with id=1 not found" in str(exc)
assert s3_file is None
s3man_client_mock.get_object.assert_called_once()
def test_process_request_calls_fail_json_when_create_authorizer_raises_exception(self, m):
self.authorizer.client.create_authorizer = mock.MagicMock(side_effect=BotoCoreError())
self.authorizer.process_request()
self.authorizer.client.create_authorizer.assert_called_once_with(
restApiId='rest_id',
name='testify',
type='TOKEN',
authType='yolo',
authorizerUri='my uri',
identitySource='source-arn'
)
self.authorizer.module.fail_json.assert_called_once_with(
msg='Error when creating authorizer via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_get_stage_raises_exception(
self):
self.stage.module.params = {'rest_api_id': 'bob', 'name': 'testme'}
self.stage.client.get_stage = mock.MagicMock(
side_effect=BotoCoreError())
self.stage.process_request()
self.stage.client.get_stage.assert_called_once_with(restApiId='bob',
stageName='testme')
self.stage.module.fail_json.assert_called_once_with(
msg=
'Error while finding stage via boto3: An unspecified error occurred'
)
def test_default_aws_retry():
# AssertionError should not retry
e = AssertionError()
assert not default_aws_retry(e)
# NotImplementedError should not retry
e = NotImplementedError()
assert not default_aws_retry(e)
# KeyError should not retry
e = KeyError()
assert not default_aws_retry(e)
# IndexError should not retry
e = IndexError()
assert not default_aws_retry(e)
# EndpointConnectionError should retry
e = EndpointConnectionError(endpoint_url=None, error=None)
assert default_aws_retry(e)
# ConnectionClosedError should retry
e = ConnectionClosedError(endpoint_url=None)
assert default_aws_retry(e)
# Generic BotoCoreError should not retry
e = BotoCoreError()
assert not default_aws_retry(e)
# Generic ClientError should not retry
err = {
"Error": {
"Code": "xxx",
"Message": "xxx"
}
}
e = ClientError(error_response=err, operation_name="xxx")
assert not default_aws_retry(e)
# ClientError with RequestLimitExceeded should retry
err = {
"Error": {
"Code": "RequestLimitExceeded",
"Message": "xxx"
}
}
e = ClientError(error_response=err, operation_name="xxx")
assert default_aws_retry(e)
def test_process_request_calls_fail_json_when_create_usage_plan_raises_exception(
self, m):
self.usage_plan.module.params = {
'name': 'testify',
'state': 'present',
}
self.usage_plan.client.create_usage_plan = mock.MagicMock(
side_effect=BotoCoreError())
self.usage_plan.process_request()
self.usage_plan.client.create_usage_plan.assert_called_once_with(
name='testify')
self.usage_plan.module.fail_json.assert_called_once_with(
msg=
'Error when creating usage_plan via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_create_api_key_raises_exception(
self, m):
self.api_key.client.create_api_key = mock.MagicMock(
side_effect=BotoCoreError())
self.api_key.process_request()
self.api_key.client.create_api_key.assert_called_once_with(
name='testify',
description='test_description',
enabled=True,
generateDistinctId=False,
value='test_value',
)
self.api_key.module.fail_json.assert_called_once_with(
msg=
'Error when creating api_key via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_update_domain_name_raises_exception(
self, m):
self.domain_name.client.update_domain_name = mock.MagicMock(
side_effect=BotoCoreError())
self.domain_name.process_request()
self.domain_name.client.update_domain_name.assert_called_once_with(
domainName='testify',
patchOperations=[{
'op': 'replace',
'path': '/certificateName',
'value': 'cert-name'
}])
self.domain_name.module.fail_json.assert_called_once_with(
msg=
'Error when updating domain_name via boto3: An unspecified error occurred'
)
def test_process_request_calls_fail_json_when_create_domain_name_raises_exception(
self, m):
self.domain_name.client.create_domain_name = mock.MagicMock(
side_effect=BotoCoreError())
self.domain_name.process_request()
self.domain_name.client.create_domain_name.assert_called_once_with(
domainName='testify',
certificateName='cert-name',
certificateBody='cert-body',
certificatePrivateKey='cert-private-key',
certificateChain='cert-chain',
)
self.domain_name.module.fail_json.assert_called_once_with(
msg=
'Error when creating domain_name via boto3: An unspecified error occurred'
)
def test_job_cloud_file(self):
# test that job_cloud_file() does not set job.status after yield
job = Job.objects.create()
job.status = Job.CLOUD_FILE_DOWNLOADED # an arbitrary one that's not PENDING (default) or SUCCESS
job.save()
with patch('utils.cloud_file.download_file') as download_file_mock:
# test when caller sets status - exposes bug where job_cloud_file() was setting to SUCCESS
with job_cloud_file(job.pk) as (job, cloud_file_fp):
job.status = Job.CLOUD_FILE_UPLOADED
job.save()
job.refresh_from_db()
self.assertEqual(Job.CLOUD_FILE_UPLOADED, job.status)
# test when __enter__() raises JobTimeoutException
job.status = Job.CLOUD_FILE_DOWNLOADED
job.save()
download_file_mock.side_effect = JobTimeoutException(
'download_file_mock Exception')
with self.assertRaises(JobTimeoutException):
with job_cloud_file(job.pk) as (job, cloud_file_fp):
pass
job.refresh_from_db()
self.assertEqual(Job.TIMEOUT, job.status)
# test when __enter__() raises BotoCoreError
job.status = Job.CLOUD_FILE_DOWNLOADED
job.save()
download_file_mock.side_effect = BotoCoreError()
with self.assertRaises(BotoCoreError):
with job_cloud_file(job.pk) as (job, cloud_file_fp):
pass
job.refresh_from_db()
self.assertEqual(Job.FAILED, job.status)
# test when __enter__() raises Exception
job.status = Job.CLOUD_FILE_DOWNLOADED
job.save()
download_file_mock.side_effect = Exception(
'download_file_mock Exception')
with self.assertRaises(Exception):
with job_cloud_file(job.pk) as (job, cloud_file_fp):
pass
job.refresh_from_db()
self.assertEqual(Job.FAILED, job.status)
def test__scores_query_worker(self):
"""
Nearly identical to test__forecasts_query_worker().
"""
# tests the worker directly. above test verifies that it's called from `query_forecasts_endpoint()`
# ensure query_scores_for_project() is called
job = Job.objects.create(user=self.po_user,
input_json={
'project_pk': self.project.pk,
'query': {}
})
with patch('utils.project_queries.query_scores_for_project') as query_mock, \
patch('utils.cloud_file.upload_file'):
_scores_query_worker(job.pk)
query_mock.assert_called_once_with(self.project, {})
# case: upload_file() does not error
job = Job.objects.create(user=self.po_user,
input_json={
'project_pk': self.project.pk,
'query': {}
})
with patch('utils.cloud_file.upload_file') as upload_mock:
_scores_query_worker(job.pk)
upload_mock.assert_called_once()
job.refresh_from_db()
self.assertEqual(Job.SUCCESS, job.status)
# case: upload_file() errors. BotoCoreError: alt: Boto3Error, ClientError, ConnectionClosedError:
job = Job.objects.create(user=self.po_user,
input_json={
'project_pk': self.project.pk,
'query': {}
})
with patch('utils.cloud_file.upload_file', side_effect=BotoCoreError()) as upload_mock, \
patch('forecast_app.notifications.send_notification_email'):
_scores_query_worker(job.pk)
upload_mock.assert_called_once()
job.refresh_from_db()
self.assertEqual(Job.FAILED, job.status)
self.assertIn("_query_worker(): error", job.failure_message)
def test_process_request_fails_when_delete_rest_api_throws_exception(self):
get_response = {
'items': [{
'id': 12345,
'name': 'whatever',
'description': 'very awesome'
}]
}
self.restapi.module.params = {'name': 'whatever', 'state': 'absent'}
self.restapi.client.get_rest_apis = mock.MagicMock(
return_value=get_response)
self.restapi.client.delete_rest_api = mock.MagicMock(
side_effect=BotoCoreError())
self.restapi.process_request()
self.restapi.client.delete_rest_api.assert_called_once_with(
restApiId=12345)
self.restapi.module.fail_json.assert_called_once_with(
msg=
'Encountered fatal error calling boto3 delete_rest_api function: An unspecified error occurred'
)
def test_mirror_failure(self):
edition, pool = self._edition(with_license_pool=True)
original_epub_location = "https://books.com/a-book.epub"
epub, ignore = pool.add_link(
Hyperlink.OPEN_ACCESS_DOWNLOAD,
original_epub_location,
edition.data_source,
Representation.EPUB_MEDIA_TYPE,
content="i'm an epub",
)
epub_rep = epub.resource.representation
uploader = self._create_s3_uploader(MockS3Client)
# A network failure is treated as a transient error.
uploader.client.fail_with = BotoCoreError()
uploader.mirror_one(epub_rep, self._url)
assert None == epub_rep.mirrored_at
assert None == epub_rep.mirror_exception
# An S3 credential failure is treated as a transient error.
response = dict(Error=dict(
Code=401,
Message="Bad credentials",
))
uploader.client.fail_with = ClientError(response, "SomeOperation")
uploader.mirror_one(epub_rep, self._url)
assert None == epub_rep.mirrored_at
assert None == epub_rep.mirror_exception
# Because the file was not successfully uploaded,
# final_mirror_url was never called and mirror_url is
# was not set.
assert None == epub_rep.mirror_url
# A bug in the code is not treated as a transient error --
# the exception propagates through.
uploader.client.fail_with = Exception("crash!")
pytest.raises(Exception, uploader.mirror_one, epub_rep, self._url)
