def test_datadog_delivery(self, mock_datadog):
datadog_mailer_config = {
'queue_url':
'asq://storageaccount.queue.core.windows.net/queuename',
'datadog_api_key': 'mock_api_key',
'datadog_application_key': 'mock_application_key'
}
datadog_compressed_message = MagicMock()
datadog_compressed_message.content = base64.b64encode(
zlib.compress(ASQ_MESSAGE_DATADOG.encode('utf8')))
datadog_loaded_message = json.loads(ASQ_MESSAGE_DATADOG)
mock_datadog.return_value\
.get_datadog_message_packages.return_value = 'mock_datadog_message_map'
azure_processor = MailerAzureQueueProcessor(datadog_mailer_config,
logger)
self.assertTrue(
azure_processor.process_azure_queue_message(
datadog_compressed_message))
mock_datadog.assert_has_calls([
call().deliver_datadog_messages('mock_datadog_message_map',
datadog_loaded_message)
])
def test_slack_delivery(self, mock_slack):
slack_mailer_config = {
'queue_url':
'asq://storageaccount.queue.core.windows.net/queuename',
'slack_token': 'mock_token'
}
slack_compressed_message = MagicMock()
slack_compressed_message.content = base64.b64encode(
zlib.compress(ASQ_MESSAGE_SLACK.encode('utf8')))
slack_loaded_message = json.loads(ASQ_MESSAGE_SLACK)
mock_slack.return_value\
.get_to_addrs_slack_messages_map.return_value = 'mock_slack_message_map'
azure_processor = MailerAzureQueueProcessor(slack_mailer_config,
logger)
self.assertTrue(
azure_processor.process_azure_queue_message(
slack_compressed_message))
mock_slack.assert_has_calls([
call().slack_handler(slack_loaded_message,
'mock_slack_message_map')
])
def test_smtp_delivery(self, mock_smtp):
smtp_mailer_config = {
'queue_url':
'asq://storageaccount.queue.core.windows.net/queuename',
'from_address': '*****@*****.**',
'smtp_port': 25,
'smtp_ssl': True,
'smtp_server': 'test_server',
'smtp_username': '******',
'smtp_password': '******'
}
with patch(
'c7n_mailer.azure_mailer.sendgrid_delivery.SendGridDelivery'
'.get_to_addrs_sendgrid_messages_map',
return_value={('*****@*****.**', ): self.loaded_message}):
azure_processor = MailerAzureQueueProcessor(
smtp_mailer_config, logger)
self.assertTrue(
azure_processor.process_azure_queue_message(
self.compressed_message))
mock_smtp.assert_has_calls([
call().send_message(message=self.loaded_message,
to_addrs=['*****@*****.**'])
])
def main():
parser = get_c7n_mailer_parser()
args = parser.parse_args()
mailer_config = get_and_validate_mailer_config(args)
args_dict = vars(args)
logger = get_logger(debug=args_dict.get('debug', False))
module_dir = path.dirname(path.abspath(__file__))
default_templates = [
path.abspath(path.join(module_dir, 'msg-templates')),
path.abspath(path.join(module_dir, '..', 'msg-templates')),
path.abspath('.')
]
templates = args_dict.get('templates', None)
if templates:
default_templates.append(
path.abspath(path.expanduser(path.expandvars(templates))))
mailer_config['templates_folders'] = default_templates
provider = get_provider(mailer_config)
if args_dict.get('update_lambda'):
if args_dict.get('debug'):
print(
'\n** --debug is only supported with --run, not --update-lambda **\n'
)
return
if args_dict.get('max_num_processes'):
print('\n** --max-num-processes is only supported '
'with --run, not --update-lambda **\n')
return
if provider == Providers.Azure:
azure_deploy.provision(mailer_config)
elif provider == Providers.AWS:
deploy.provision(mailer_config,
functools.partial(session_factory, mailer_config))
if args_dict.get('run'):
max_num_processes = args_dict.get('max_num_processes')
# Select correct processor
if provider == Providers.Azure:
processor = MailerAzureQueueProcessor(mailer_config, logger)
elif provider == Providers.AWS:
aws_session = session_factory(mailer_config)
processor = MailerSqsQueueProcessor(mailer_config, aws_session,
logger)
# Execute
if max_num_processes:
run_mailer_in_parallel(processor, max_num_processes)
else:
processor.run()
def start_c7n_mailer(logger, config, auth_file):
try:
logger.info('c7n_mailer starting...')
session = Session(authorization_file=auth_file,
resource=RESOURCE_STORAGE)
mailer_azure_queue_processor = MailerAzureQueueProcessor(
config, logger, session=session)
mailer_azure_queue_processor.run()
except Exception as e:
logger.exception(
"Error starting mailer MailerAzureQueueProcessor(). \n Error: %s \n"
% (e))
def test_run(self, mock_get_messages, mock_delete, mock_client,
mock_process):
mock_get_messages.side_effect = [[self.compressed_message], []]
mock_client.return_value = (None, None)
mock_process.return_value = True
# Run the 'run' method
azure_processor = MailerAzureQueueProcessor(MAILER_CONFIG_AZURE,
logger)
azure_processor.run(False)
self.assertEqual(2, mock_get_messages.call_count)
self.assertEqual(1, mock_process.call_count)
mock_delete.assert_called()
def test_process_azure_queue_message_failure(self, mock_get_addr,
mock_handler):
mock_handler.return_value = False
mock_get_addr.return_value = 42
# Run the process messages method
azure_processor = MailerAzureQueueProcessor(MAILER_CONFIG_AZURE,
logger)
self.assertFalse(
azure_processor.process_azure_queue_message(
self.compressed_message))
# Verify mock calls were correct
mock_get_addr.assert_called_with(self.loaded_message)
mock_handler.assert_called_with(self.loaded_message, 42)
