├── test
    ├── __init__.py
    ├── test_terraform.py
    ├── test_lambda_converter.py
    └── test_lambda_slack.py
├── lambda_converter
    ├── __init__.py
    └── lambda_function.py
├── lambda_slack
    ├── __init__.py
    └── lambda_function.py
├── README.md
├── outputs.tf
├── requirements.txt
├── variables.tf
├── .gitignore
└── main.tf


/test/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/lambda_converter/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/lambda_slack/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # stdf-alert-pipeline
2 | Standard alerting pipeline for stdf format
3 | 


--------------------------------------------------------------------------------
/outputs.tf:
--------------------------------------------------------------------------------
1 | output "incoming_sns_arn" {
2 |   value = aws_sns_topic.incoming.arn
3 | }
4 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | https://github.com/foursquare-oss/terraform_validate/archive/master.zip
2 | boto3
3 | 


--------------------------------------------------------------------------------
/variables.tf:
--------------------------------------------------------------------------------
 1 | variable "name" {
 2 |   description = "The name of the pipeline"
 3 | }
 4 | 
 5 | variable "allowed_accounts" {
 6 |   description = "The account numbers allowed to post to the pipeline"
 7 | }
 8 | 
 9 | variable "fallback_sns" {
10 |   description = "The SNS topic arn to post any lambda failures to"
11 | }
12 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # terraform stuff
 2 | **/.terraform
 3 | *.tfstate
 4 | *.tfstate.*
 5 | crash.log
 6 | 
 7 | # IDEs
 8 | .idea/**
 9 | .vscode
10 | .vsls.json
11 | **/*.code-workspace
12 | 
13 | # Mac stuff
14 | **/.DS_Store
15 | .DS_Store
16 | 
17 | # Terraform lambda packing stuff
18 | lambda*.zip
19 | 
20 | # Python stuff
21 | __pycache__
22 | *.pyc
23 | 


--------------------------------------------------------------------------------
/lambda_converter/lambda_function.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import boto3
 3 | import os
 4 | import logging
 5 | import datetime
 6 | 
 7 | 
 8 | def error_if_not_exactly_one_record(event):
 9 |     number_of_records = len(event['Records'])
10 |     if (number_of_records != 1):
11 |         raise Exception(
12 |             f'Received SNS message with {number_of_records} records. This should never happen: AWS states all lambda SNS messages will always have exactly one record.')
13 | 
14 | 
15 | def get_subject_and_message(event):
16 |     subject = event['Records'][0]['Sns']['Subject']
17 |     message = event['Records'][0]['Sns']['Message']
18 |     return subject, message
19 | 
20 | 
21 | def parse_metric_to_stdf(message):
22 |     parsed_message = json.loads(message)
23 |     aws_time_format = '%Y-%m-%dT%H:%M:%S.%f%z'
24 |     timestamp = int(datetime.datetime.strptime(parsed_message['StateChangeTime'], aws_time_format).timestamp() * 1000)
25 |     alarm_name = parsed_message['AlarmName']
26 |     stdf_message = {
27 |         'payload': {
28 |             'title': alarm_name,
29 |             'description': parsed_message['AlarmDescription'],
30 |             'raw_data': parsed_message['NewStateReason']
31 |         },
32 |         'meta': {
33 |             'timestamp': timestamp,
34 |             'source': {
35 |                 'provider': 'AWS',
36 |                 'account_id': parsed_message['AWSAccountId'],
37 |                 'region': parsed_message['Region'],
38 |                 'service': 'CloudWatch',
39 |                 'app_name': 'Metric Alarm'
40 |             },
41 |             'urls': [{
42 |                 'url': f'https://console.aws.amazon.com/cloudwatch/home#alarmsV2:alarm/{alarm_name}',
43 |                 'text': 'Show alarm details'
44 |             }]
45 |         },
46 |         'stdf_version': 2,
47 |     }
48 | 
49 |     return json.dumps(stdf_message)
50 | 
51 | 
52 | def post_stdf_string_to_sns(message):
53 |     sns = boto3.client('sns')
54 |     subject = f'stdf: {json.loads(message)["payload"]["title"]}'
55 |     sns.publish(
56 |         TopicArn=os.getenv('OUTGOING_SNS_TOPIC'),
57 |         Subject=(subject[:88] + '[TRUNCATED]') if len(subject) > 99 else subject,
58 |         Message=message
59 |     )
60 | 
61 | 
62 | def post_unrecognized_to_sns_and_warn(message, event):
63 |     log = logging.getLogger('Unrecognized Message Format')
64 |     log.warn(event)
65 |     sns = boto3.client('sns')
66 |     sns.publish(
67 |         TopicArn=os.getenv('OUTGOING_SNS_TOPIC'),
68 |         Subject='unrecognizedNonStdfMessage',
69 |         Message=message
70 |     )
71 | 
72 | 
73 | def log_event(event):
74 |     print(event)
75 | 
76 | 
77 | def lambda_handler(event, context):
78 |     log_event(event)
79 |     error_if_not_exactly_one_record(event)
80 |     subject, message = get_subject_and_message(event)
81 | 
82 |     if subject == 'stdfMessage':
83 |         post_stdf_string_to_sns(message)
84 |     elif subject.startswith('ALARM: '):
85 |         stdf_message = parse_metric_to_stdf(message)
86 |         post_stdf_string_to_sns(stdf_message)
87 |     else:
88 |         post_unrecognized_to_sns_and_warn(message, event)
89 | 


--------------------------------------------------------------------------------
/lambda_slack/lambda_function.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import http.client
  3 | import datetime
  4 | import os
  5 | import boto3
  6 | 
  7 | def error_if_not_exactly_one_record(event):
  8 |     number_of_records = len(event['Records'])
  9 |     if number_of_records != 1:
 10 |         raise Exception(
 11 |             f'Received SNS message with {number_of_records} records. This should never happen: AWS states all lambda SNS messages will always have exactly one record.')
 12 | 
 13 | 
 14 | def get_subject_and_message(event):
 15 |     subject = event['Records'][0]['Sns']['Subject']
 16 |     message = event['Records'][0]['Sns']['Message']
 17 |     return subject, message
 18 | 
 19 | 
 20 | def get_webhook():
 21 |     sm = boto3.client('secretsmanager')
 22 |     return json.loads(sm.get_secret_value(SecretId=os.environ['SLACK_WEBHOOK_SECRET_ID'])['SecretString'])
 23 | 
 24 | 
 25 | def get_zulu_timestamp(unix_time_milliseconds):
 26 |     return datetime.datetime.fromtimestamp(unix_time_milliseconds // 1000, tz=datetime.timezone(datetime.timedelta(0))).isoformat().replace('+00:00', 'Z')
 27 | 
 28 | 
 29 | def format_urls(urls):
 30 |     formatted_urls = ''
 31 |     first = True
 32 |     for url in urls:
 33 |         if first:
 34 |             first = False
 35 |         else:
 36 |             formatted_urls += ' - '
 37 |         formatted_urls += f"<{url['url']}|{url['text']}>"
 38 | 
 39 |     return formatted_urls
 40 | 
 41 | 
 42 | def format_stdf(stdf_message):
 43 |     stdf_parsed = json.loads(stdf_message)
 44 |     app_name = stdf_parsed['meta']['source']['app_name']
 45 |     alert_title = stdf_parsed['payload']['title']
 46 |     description = stdf_parsed['payload']['description']
 47 |     log_line = stdf_parsed['payload']['raw_data']
 48 |     provider = stdf_parsed['meta']['source']['provider']
 49 |     service_name = stdf_parsed['meta']['source']['service']
 50 |     account_id = stdf_parsed['meta']['source']['account_id']
 51 |     zulu_timestamp = get_zulu_timestamp(stdf_parsed['meta']['timestamp'])
 52 | 
 53 |     divider = {'type': 'divider'}
 54 |     header_section = {
 55 |         'type': 'section',
 56 |         'text': {
 57 |             'type': 'mrkdwn',
 58 |             'text': f'*{app_name}*: *{alert_title}*'
 59 |         }
 60 |     }
 61 |     description_section = {
 62 |         'type': 'section',
 63 |         'text': {
 64 |             'type': 'mrkdwn',
 65 |             'text': description
 66 |         }
 67 |     }
 68 |     log_line_section = {
 69 |         'type': 'section',
 70 |         'text': {
 71 |             'type': 'mrkdwn',
 72 |             'text': f'```{log_line}```'
 73 |         }
 74 |     }
 75 |     meta_section = {
 76 |         'type': 'section',
 77 |         'fields': [
 78 |             {
 79 |                 'type': 'mrkdwn',
 80 |                 'text': f'*Source:* {provider} {service_name}'
 81 |             },
 82 |             {
 83 |                 'type': 'mrkdwn',
 84 |                 'text': f'*Account id:* {account_id}'
 85 |             },
 86 |             {
 87 |                 'type': 'mrkdwn',
 88 |                 'text': f'*Timestamp*: {zulu_timestamp}'
 89 |             },
 90 |             {
 91 |                 'type': 'mrkdwn',
 92 |                 'text': '*Region:* us-east-1'
 93 |             }
 94 |         ]
 95 |     }
 96 |     blocks = [
 97 |         header_section,
 98 |         description_section,
 99 |         log_line_section,
100 |         divider,
101 |         meta_section,
102 |         divider,
103 |     ]
104 | 
105 |     urls = stdf_parsed['meta'].get('urls')
106 |     if urls is not None:
107 |         links = format_urls(urls)
108 |         links_section = {
109 |             'type': 'section',
110 |             'text': {
111 |                 'type': 'mrkdwn',
112 |                 'text': links
113 |             }
114 |         }
115 |         blocks.append(links_section)
116 | 
117 |     event_id = stdf_parsed['meta']['source'].get('event_id')
118 |     if event_id is not None:
119 |         event_id_section = {
120 |             'type': 'context',
121 |             'elements': [
122 |                 {
123 |                     'type': 'mrkdwn',
124 |                     'text': f'*Event id*: {event_id}'
125 |                 }
126 |             ]
127 |         }
128 |         blocks.append(event_id_section)
129 | 
130 |     return {'blocks': blocks}
131 | 
132 | 
133 | def format_fallback(message, fallback_reason):
134 |     return {'text': f'{fallback_reason}. Failed to format the message. Using fallback mode!\n{message}'}
135 | 
136 | 
137 | def post_to_slack(webhook, slack_message):
138 |     dumped_message = json.dumps(slack_message)
139 |     conn = http.client.HTTPSConnection(webhook['host'], 443)
140 |     conn.request(
141 |         'POST',
142 |         webhook['path'],
143 |         body=dumped_message,
144 |         headers={
145 |             'Content-Type': 'application/json'
146 |         })
147 | 
148 |     status = conn.getresponse().status
149 | 
150 |     if status != http.HTTPStatus.OK:
151 |         raise Exception(f"Request to slack returned an error {status}")
152 | 
153 | 
154 | def lambda_handler(event, context):
155 |     error_if_not_exactly_one_record(event)
156 |     subject, message = get_subject_and_message(event)
157 |     webhook = get_webhook()
158 | 
159 |     if subject != 'stdfMessage' and not subject.startswith('stdf: '):
160 |         fallback_slack_message = format_fallback(message, fallback_reason=subject)
161 |         post_to_slack(webhook, fallback_slack_message)
162 |         return
163 | 
164 |     try:
165 |         slack_message = format_stdf(message)
166 |         post_to_slack(webhook, slack_message)
167 |     except ValueError as error:
168 |         fallback_slack_message = format_fallback(message, fallback_reason=str(error))
169 |         post_to_slack(webhook, fallback_slack_message)
170 | 


--------------------------------------------------------------------------------
/main.tf:
--------------------------------------------------------------------------------
  1 | resource "aws_sns_topic" "incoming" {
  2 |   name = "stdf-alert-pipeline-${var.name}-incoming"
  3 | }
  4 | 
  5 | resource "aws_sns_topic_policy" "incoming_cross_account" {
  6 |   arn = aws_sns_topic.incoming.arn
  7 |   policy = data.aws_iam_policy_document.incoming_sns_cross_account.json
  8 | }
  9 | 
 10 | data "aws_iam_policy_document" "incoming_sns_cross_account" {
 11 |   statement {
 12 |     sid = "CrossAccount"
 13 |     actions = [
 14 |       "SNS:Publish"
 15 |     ]
 16 |     resources = [
 17 |       aws_sns_topic.incoming.arn
 18 |     ]
 19 |     effect = "Allow"
 20 |     principals {
 21 |       type = "AWS"
 22 |       identifiers = var.allowed_accounts
 23 |     }
 24 |   }
 25 | 
 26 |   statement {
 27 |     sid = "CrossAccountWithCloudWatch"
 28 |     actions = [
 29 |       "SNS:Publish"
 30 |     ]
 31 |     resources = [
 32 |       aws_sns_topic.incoming.arn
 33 |     ]
 34 |     effect = "Allow"
 35 |     principals {
 36 |       type = "AWS"
 37 |       identifiers = [
 38 |         "*"
 39 |       ]
 40 |     }
 41 |     condition {
 42 |       test = "StringEquals"
 43 |       variable = "AWS:SourceOwner"
 44 |       values = var.allowed_accounts
 45 |     }
 46 |   }
 47 | }
 48 | 
 49 | resource "aws_sns_topic_subscription" "incoming" {
 50 |   topic_arn = aws_sns_topic.incoming.arn
 51 |   protocol = "lambda"
 52 |   endpoint = aws_lambda_function.converter_lambda.arn
 53 | }
 54 | 
 55 | resource "aws_lambda_permission" "converter_lambda_with_sns" {
 56 |   statement_id  = "AllowExecutionFromSNS"
 57 |   action        = "lambda:InvokeFunction"
 58 |   function_name = aws_lambda_function.converter_lambda.arn
 59 |   principal     = "sns.amazonaws.com"
 60 |   source_arn    = aws_sns_topic.incoming.arn
 61 | }
 62 | 
 63 | data "archive_file" "converter_lambda_zip" {
 64 |   type        = "zip"
 65 |   source_dir  = "${path.module}/lambda_converter"
 66 |   output_path = "${path.module}/lambda_converter.zip"
 67 | }
 68 | 
 69 | resource "aws_lambda_function" "converter_lambda" {
 70 |   filename         = "${path.module}/lambda_converter.zip"
 71 |   source_code_hash = data.archive_file.converter_lambda_zip.output_base64sha256
 72 |   function_name    = "stdf-alert-pipeline-${var.name}-converter"
 73 |   description      = "Converts alerts from various formats into STDF"
 74 |   handler          = "lambda_function.lambda_handler"
 75 |   runtime          = "python3.7"
 76 |   role             = aws_iam_role.converter_lambda.arn
 77 |   environment {
 78 |     variables = {
 79 |       OUTGOING_SNS_TOPIC = aws_sns_topic.fanout.arn
 80 |     }
 81 |   }
 82 |   timeout     = 10
 83 |   memory_size = 128
 84 | }
 85 | 
 86 | data "aws_iam_policy" "basic_execution_role_policy" {
 87 |   arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
 88 | }
 89 | 
 90 | resource "aws_iam_role" "converter_lambda" {
 91 |   name               = "stdf-alert-pipeline-${var.name}-converter"
 92 |   path               = "/"
 93 |   assume_role_policy = <<POLICY
 94 | {
 95 |   "Version": "2012-10-17",
 96 |   "Statement": [
 97 |     {
 98 |       "Action": "sts:AssumeRole",
 99 |       "Effect": "Allow",
100 |       "Principal": {
101 |         "Service": "lambda.amazonaws.com"
102 |       }
103 |     }
104 |   ]
105 | }
106 | POLICY
107 | }
108 | 
109 | resource "aws_iam_role_policy" "converter_lambda" {
110 |   name   = "stdf-alert-pipeline-${var.name}-converter"
111 |   role   = aws_iam_role.converter_lambda.id
112 |   policy = <<POLICY
113 | {
114 |   "Version": "2012-10-17",
115 |   "Statement": [
116 |     {
117 |       "Effect": "Allow",
118 |       "Action": [
119 |         "sns:Publish"
120 |       ],
121 |       "Resource": [
122 |         "${aws_sns_topic.fanout.arn}"
123 |       ]
124 |     }
125 |   ]
126 | }
127 | POLICY
128 | }
129 | 
130 | resource "aws_iam_role_policy_attachment" "converter_lambda_basic_execution_role_policy" {
131 |   role       = aws_iam_role.converter_lambda.name
132 |   policy_arn = data.aws_iam_policy.basic_execution_role_policy.arn
133 | }
134 | 
135 | 
136 | resource "aws_cloudwatch_metric_alarm" "converter_lambda_alarm" {
137 |   alarm_name          = "stdf-alert-pipeline-${var.name}-converter-alarm"
138 |   alarm_description   = "STDF alert pipeline ${var.name} FAILED at the converter lambda!"
139 |   comparison_operator = "GreaterThanOrEqualToThreshold"
140 |   evaluation_periods  = "1"
141 |   metric_name         = "Errors"
142 |   namespace           = "AWS/Lambda"
143 |   dimensions = {
144 |     FunctionName = aws_lambda_function.converter_lambda.function_name
145 |   }
146 |   threshold                 = "1"
147 |   period                    = "60"
148 |   statistic                 = "Sum"
149 |   treat_missing_data        = "missing"
150 |   insufficient_data_actions = []
151 |   alarm_actions             = [var.fallback_sns]
152 | }
153 | 
154 | resource "aws_sns_topic" "fanout" {
155 |   name = "stdf-alert-pipeline-${var.name}-fanout"
156 | }
157 | 
158 | resource "aws_sns_topic_subscription" "fanout" {
159 |   topic_arn = aws_sns_topic.fanout.arn
160 |   protocol = "lambda"
161 |   endpoint = aws_lambda_function.slack_lambda.arn
162 | }
163 | 
164 | resource "aws_lambda_permission" "slack_lambda_with_sns" {
165 |   statement_id  = "AllowExecutionFromSNS"
166 |   action        = "lambda:InvokeFunction"
167 |   function_name = aws_lambda_function.slack_lambda.arn
168 |   principal     = "sns.amazonaws.com"
169 |   source_arn    = aws_sns_topic.fanout.arn
170 | }
171 | 
172 | data "archive_file" "slack_lambda_zip" {
173 |   type        = "zip"
174 |   source_dir  = "${path.module}/lambda_slack"
175 |   output_path = "${path.module}/lambda_slack.zip"
176 | }
177 | 
178 | resource "aws_lambda_function" "slack_lambda" {
179 |   filename         = "${path.module}/lambda_slack.zip"
180 |   source_code_hash = data.archive_file.slack_lambda_zip.output_base64sha256
181 |   function_name    = "stdf-alert-pipeline-${var.name}-slack"
182 |   description      = "Posts STDF alerts to slack"
183 |   handler          = "lambda_function.lambda_handler"
184 |   runtime          = "python3.7"
185 |   role             = aws_iam_role.slack_lambda.arn
186 |   environment {
187 |     variables = {
188 |       SLACK_WEBHOOK_SECRET_ID = aws_secretsmanager_secret.slack_webhook.id
189 |     }
190 |   }
191 |   timeout     = 10
192 |   memory_size = 128
193 | }
194 | 
195 | resource "aws_iam_role" "slack_lambda" {
196 |   name               = "stdf-alert-pipeline-${var.name}-slack"
197 |   path               = "/"
198 |   assume_role_policy = <<POLICY
199 | {
200 |   "Version": "2012-10-17",
201 |   "Statement": [
202 |     {
203 |       "Action": "sts:AssumeRole",
204 |       "Effect": "Allow",
205 |       "Principal": {
206 |         "Service": "lambda.amazonaws.com"
207 |       }
208 |     }
209 |   ]
210 | }
211 | POLICY
212 | }
213 | 
214 | resource "aws_iam_role_policy" "slack_lambda" {
215 |   name   = "stdf-alert-pipeline-${var.name}-slack"
216 |   role   = aws_iam_role.slack_lambda.id
217 |   policy = <<POLICY
218 | {
219 |   "Version": "2012-10-17",
220 |   "Statement": [
221 |     {
222 |       "Effect": "Allow",
223 |       "Action": [
224 |         "secretsmanager:GetSecretValue"
225 |       ],
226 |       "Resource": [
227 |         "${aws_secretsmanager_secret.slack_webhook.arn}"
228 |       ]
229 |     }
230 |   ]
231 | }
232 | POLICY
233 | }
234 | 
235 | resource "aws_iam_role_policy_attachment" "slack_lambda_basic_execution_role_policy" {
236 |   role       = aws_iam_role.slack_lambda.name
237 |   policy_arn = data.aws_iam_policy.basic_execution_role_policy.arn
238 | }
239 | 
240 | resource "aws_cloudwatch_metric_alarm" "slack_lambda_alarm" {
241 |   alarm_name          = "stdf-alert-pipeline-${var.name}-slack-alarm"
242 |   alarm_description   = "STDF alert pipeline ${var.name} FAILED at the slack lambda!"
243 |   comparison_operator = "GreaterThanOrEqualToThreshold"
244 |   evaluation_periods  = "1"
245 |   metric_name         = "Errors"
246 |   namespace           = "AWS/Lambda"
247 |   dimensions = {
248 |     FunctionName = aws_lambda_function.slack_lambda.function_name
249 |   }
250 |   threshold                 = "1"
251 |   period                    = "60"
252 |   statistic                 = "Sum"
253 |   treat_missing_data        = "missing"
254 |   insufficient_data_actions = []
255 |   alarm_actions             = [var.fallback_sns]
256 | }
257 | 
258 | resource "aws_secretsmanager_secret" "slack_webhook" {
259 |   name = "stdf-alert-pipeline-${var.name}-slack-webhook"
260 | }
261 | 


--------------------------------------------------------------------------------
/test/test_terraform.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import unittest
  3 | import json
  4 | import terraform_validate
  5 | 
  6 | 
  7 | class TestTerraformConfig(unittest.TestCase):
  8 |     @classmethod
  9 |     def setUpClass(cls):
 10 |         cls.path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')
 11 |         return super().setUpClass()
 12 | 
 13 |     @classmethod
 14 |     def tearDownClass(cls):
 15 |         return super().tearDownClass()
 16 | 
 17 |     def setUp(self):
 18 |         self.validator = terraform_validate.Validator(self.path)
 19 |         self.validator.error_if_property_missing()
 20 |         return super().setUp()
 21 | 
 22 |     def tearDown(self):
 23 |         return super().tearDown()
 24 | 
 25 |     def get_resources_by_type_and_name(self, resource_type, resource_name):
 26 |         all_of_type = self.validator.resources(resource_type)
 27 |         resources = terraform_validate.TerraformResourceList(all_of_type.validator, all_of_type.resource_types, {})
 28 |         for resource in all_of_type.resource_list:
 29 |             if resource.name == resource_name:
 30 |                 resources.resource_list.append(resource)
 31 |         return resources
 32 | 
 33 |     def assert_resources_match(self, resources, spec):
 34 |         for resource_property in spec:
 35 |             resources.property(resource_property).should_equal(spec[resource_property])
 36 |         return
 37 | 
 38 |     def test_incoming_sns_topic(self):
 39 |         # Arrange
 40 |         expected_resource_type = 'aws_sns_topic'
 41 |         expected_resource_name = 'incoming'
 42 |         expected_number_of_resources = 1
 43 |         expected_properties = {
 44 |             'name': 'stdf-alert-pipeline-${var.name}-incoming',
 45 |         }
 46 | 
 47 |         # Act
 48 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
 49 | 
 50 |         # Assert
 51 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
 52 |         self.assert_resources_match(actual_resources, expected_properties)
 53 | 
 54 |     def test_incoming_sns_topic_policy(self):
 55 |         # Arrange
 56 |         expected_number_of_resources = 1
 57 |         expected_resource_type = 'aws_sns_topic_policy'
 58 |         expected_resource_name = 'incoming_cross_account'
 59 | 
 60 |         expected_properties = {
 61 |             'arn': 'aws_sns_topic.incoming.arn',
 62 |             'policy': 'data.aws_iam_policy_document.incoming_sns_cross_account.json'
 63 |         }
 64 | 
 65 |         # Act
 66 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
 67 | 
 68 |         # Assert
 69 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
 70 |         self.assert_resources_match(actual_resources, expected_properties)
 71 | 
 72 |     def test_incoming_sns_subscription(self):
 73 |         # Arrange
 74 |         expected_resource_type = 'aws_sns_topic_subscription'
 75 |         expected_resource_name = 'incoming'
 76 |         expected_number_of_resources = 1
 77 |         expected_properties = {
 78 |             'topic_arn': 'aws_sns_topic.incoming.arn',
 79 |             'protocol': 'lambda',
 80 |             'endpoint': 'aws_lambda_function.converter_lambda.arn',
 81 |         }
 82 | 
 83 |         # Act
 84 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
 85 | 
 86 |         # Assert
 87 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
 88 |         self.assert_resources_match(actual_resources, expected_properties)
 89 | 
 90 | 
 91 |     def test_converter_lambda_permission(self):
 92 |         # Arrange
 93 |         expected_resource_type = 'aws_lambda_permission'
 94 |         expected_resource_name = 'converter_lambda_with_sns'
 95 |         expected_number_of_resources = 1
 96 |         expected_properties = {
 97 |             'statement_id': 'AllowExecutionFromSNS',
 98 |             'action': "lambda:InvokeFunction",
 99 |             'function_name': 'aws_lambda_function.converter_lambda.arn',
100 |             'principal': 'sns.amazonaws.com',
101 |             'source_arn': 'aws_sns_topic.incoming.arn'
102 |         }
103 | 
104 |         # Act
105 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
106 | 
107 |         # Assert
108 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
109 |         self.assert_resources_match(actual_resources, expected_properties)
110 | 
111 |     def test_converter_lambda_function(self):
112 |         # Arrange
113 |         expected_resource_type = 'aws_lambda_function'
114 |         expected_resource_name = 'converter_lambda'
115 |         expected_number_of_resources = 1
116 | 
117 |         expected_environment = {
118 |             'variables': {
119 |                 'OUTGOING_SNS_TOPIC': 'aws_sns_topic.fanout.arn',
120 |             }
121 |         }
122 | 
123 |         expected_properties = {
124 |             'filename': '${path.module}/lambda_converter.zip',
125 |             'source_code_hash': 'data.archive_file.converter_lambda_zip.output_base64sha256',
126 |             'function_name': 'stdf-alert-pipeline-${var.name}-converter',
127 |             'description': 'Converts alerts from various formats into STDF',
128 |             'handler': 'lambda_function.lambda_handler',
129 |             'runtime': 'python3.7',
130 |             'role': 'aws_iam_role.converter_lambda.arn',
131 |             'environment': expected_environment,
132 |             'timeout': 10,
133 |             'memory_size': 128
134 |         }
135 | 
136 |         # Act
137 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
138 | 
139 |         # Assert
140 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
141 |         self.assert_resources_match(actual_resources, expected_properties)
142 | 
143 |     def test_converter_lambda_role(self):
144 |         # Arrange
145 |         expected_number_of_resources = 1
146 |         expected_resource_type = 'aws_iam_role'
147 |         expected_resource_name = 'converter_lambda'
148 | 
149 |         expected_assume_role_policy = {
150 |             'Version': '2012-10-17',
151 |             'Statement': [
152 |                 {
153 |                     'Action': 'sts:AssumeRole',
154 |                     'Effect': 'Allow',
155 |                     'Principal': {
156 |                         'Service': 'lambda.amazonaws.com'
157 |                     }
158 |                 }
159 |             ]
160 |         }
161 | 
162 |         expected_properties = {
163 |             'name': 'stdf-alert-pipeline-${var.name}-converter',
164 |             'path': '/',
165 |             'assume_role_policy': json.dumps(expected_assume_role_policy, indent=2),
166 |         }
167 | 
168 |         # Act
169 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
170 | 
171 |         # Assert
172 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
173 |         self.assert_resources_match(actual_resources, expected_properties)
174 | 
175 |     def test_converter_lambda_role_policy(self):
176 |         # Arrange
177 |         expected_number_of_resources = 1
178 |         expected_resource_type = 'aws_iam_role_policy'
179 |         expected_resource_name = 'converter_lambda'
180 | 
181 |         expected_inline_role_policy = {
182 |             'Version': '2012-10-17',
183 |             'Statement': [
184 |                 {
185 |                     'Effect': 'Allow',
186 |                     'Action': [
187 |                         'sns:Publish'
188 |                     ],
189 |                     'Resource': [
190 |                         '${aws_sns_topic.fanout.arn}'
191 |                     ]
192 |                 }
193 |             ]
194 |         }
195 | 
196 |         expected_properties = {
197 |             'name': 'stdf-alert-pipeline-${var.name}-converter',
198 |             'role': 'aws_iam_role.converter_lambda.id',
199 |             'policy': json.dumps(expected_inline_role_policy, indent=2),
200 |         }
201 | 
202 |         # Act
203 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
204 | 
205 |         # Assert
206 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
207 |         self.assert_resources_match(actual_resources, expected_properties)
208 | 
209 |     def test_converter_lambda_alarm(self):
210 |         # Arrange
211 |         expected_number_of_resources = 1
212 |         expected_resource_type = 'aws_cloudwatch_metric_alarm'
213 |         expected_resource_name = 'converter_lambda_alarm'
214 | 
215 |         expected_properties = {
216 |             'alarm_name': 'stdf-alert-pipeline-${var.name}-converter-alarm',
217 |             'alarm_description': 'STDF alert pipeline ${var.name} FAILED at the converter lambda!',
218 |             'comparison_operator': 'GreaterThanOrEqualToThreshold',
219 |             'evaluation_periods': '1',
220 |             'metric_name': 'Errors',
221 |             'namespace': 'AWS/Lambda',
222 |             'dimensions': {
223 |                 'FunctionName': 'aws_lambda_function.converter_lambda.function_name'
224 |             },
225 |             'threshold': '1',
226 |             'period': '60',
227 |             'statistic': 'Sum',
228 |             'treat_missing_data': 'missing',
229 |             'insufficient_data_actions': [],
230 |             'alarm_actions': ['var.fallback_sns'],
231 |         }
232 | 
233 |         # Act
234 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
235 | 
236 |         # Assert
237 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
238 |         self.assert_resources_match(actual_resources, expected_properties)
239 | 
240 |     def test_fanout_sns_topic(self):
241 |         # Arrange
242 |         expected_resource_type = 'aws_sns_topic'
243 |         expected_resource_name = 'fanout'
244 |         expected_number_of_resources = 1
245 |         expected_properties = {
246 |             'name': 'stdf-alert-pipeline-${var.name}-fanout',
247 |         }
248 | 
249 |         # Act
250 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
251 | 
252 |         # Assert
253 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
254 |         self.assert_resources_match(actual_resources, expected_properties)
255 | 
256 |     def test_fanout_sns_subscription(self):
257 |         # Arrange
258 |         expected_resource_type = 'aws_sns_topic_subscription'
259 |         expected_resource_name = 'fanout'
260 |         expected_number_of_resources = 1
261 |         expected_properties = {
262 |             'topic_arn': 'aws_sns_topic.fanout.arn',
263 |             'protocol': 'lambda',
264 |             'endpoint': 'aws_lambda_function.slack_lambda.arn',
265 |         }
266 | 
267 |         # Act
268 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
269 | 
270 |         # Assert
271 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
272 |         self.assert_resources_match(actual_resources, expected_properties)
273 | 
274 |     def test_slack_lambda_permission(self):
275 |         # Arrange
276 |         expected_resource_type = 'aws_lambda_permission'
277 |         expected_resource_name = 'slack_lambda_with_sns'
278 |         expected_number_of_resources = 1
279 |         expected_properties = {
280 |             'statement_id': 'AllowExecutionFromSNS',
281 |             'action': "lambda:InvokeFunction",
282 |             'function_name': 'aws_lambda_function.slack_lambda.arn',
283 |             'principal': 'sns.amazonaws.com',
284 |             'source_arn': 'aws_sns_topic.fanout.arn'
285 |         }
286 | 
287 |         # Act
288 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
289 | 
290 |         # Assert
291 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
292 |         self.assert_resources_match(actual_resources, expected_properties)
293 | 
294 |     def test_slack_lambda_function(self):
295 |         # Arrange
296 |         expected_resource_type = 'aws_lambda_function'
297 |         expected_resource_name = 'slack_lambda'
298 |         expected_number_of_resources = 1
299 | 
300 |         expected_environment = {
301 |             'variables': {
302 |                 'SLACK_WEBHOOK_SECRET_ID': 'aws_secretsmanager_secret.slack_webhook.id',
303 |             }
304 |         }
305 | 
306 |         expected_properties = {
307 |             'filename': '${path.module}/lambda_slack.zip',
308 |             'source_code_hash': 'data.archive_file.slack_lambda_zip.output_base64sha256',
309 |             'function_name': 'stdf-alert-pipeline-${var.name}-slack',
310 |             'description': 'Posts STDF alerts to slack',
311 |             'handler': 'lambda_function.lambda_handler',
312 |             'runtime': 'python3.7',
313 |             'role': 'aws_iam_role.slack_lambda.arn',
314 |             'environment': expected_environment,
315 |             'timeout': 10,
316 |             'memory_size': 128
317 |         }
318 | 
319 |         # Act
320 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
321 | 
322 |         # Assert
323 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
324 |         self.assert_resources_match(actual_resources, expected_properties)
325 | 
326 |     def test_slack_lambda_role(self):
327 |         # Arrange
328 |         expected_number_of_resources = 1
329 |         expected_resource_type = 'aws_iam_role'
330 |         expected_resource_name = 'slack_lambda'
331 | 
332 |         expected_assume_role_policy = {
333 |             'Version': '2012-10-17',
334 |             'Statement': [
335 |                 {
336 |                     'Action': 'sts:AssumeRole',
337 |                     'Effect': 'Allow',
338 |                     'Principal': {
339 |                         'Service': 'lambda.amazonaws.com'
340 |                     }
341 |                 }
342 |             ]
343 |         }
344 | 
345 |         expected_properties = {
346 |             'name': 'stdf-alert-pipeline-${var.name}-slack',
347 |             'path': '/',
348 |             'assume_role_policy': json.dumps(expected_assume_role_policy, indent=2),
349 |         }
350 | 
351 |         # Act
352 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
353 | 
354 |         # Assert
355 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
356 |         self.assert_resources_match(actual_resources, expected_properties)
357 | 
358 |     def test_slack_lambda_role_policy(self):
359 |         # Arrange
360 |         expected_number_of_resources = 1
361 |         expected_resource_type = 'aws_iam_role_policy'
362 |         expected_resource_name = 'slack_lambda'
363 | 
364 |         expected_inline_role_policy = {
365 |             'Version': '2012-10-17',
366 |             'Statement': [
367 |                 {
368 |                     'Effect': 'Allow',
369 |                     'Action': [
370 |                         'secretsmanager:GetSecretValue'
371 |                     ],
372 |                     'Resource': [
373 |                         '${aws_secretsmanager_secret.slack_webhook.arn}'
374 |                     ]
375 |                 }
376 |             ]
377 |         }
378 | 
379 |         expected_properties = {
380 |             'name': 'stdf-alert-pipeline-${var.name}-slack',
381 |             'role': 'aws_iam_role.slack_lambda.id',
382 |             'policy': json.dumps(expected_inline_role_policy, indent=2),
383 |         }
384 | 
385 |         # Act
386 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
387 | 
388 |         # Assert
389 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
390 |         self.assert_resources_match(actual_resources, expected_properties)
391 | 
392 |     def test_slack_lambda_alarm(self):
393 |         # Arrange
394 |         expected_number_of_resources = 1
395 |         expected_resource_type = 'aws_cloudwatch_metric_alarm'
396 |         expected_resource_name = 'slack_lambda_alarm'
397 | 
398 |         expected_properties = {
399 |             'alarm_name': 'stdf-alert-pipeline-${var.name}-slack-alarm',
400 |             'alarm_description': 'STDF alert pipeline ${var.name} FAILED at the slack lambda!',
401 |             'comparison_operator': 'GreaterThanOrEqualToThreshold',
402 |             'evaluation_periods': '1',
403 |             'metric_name': 'Errors',
404 |             'namespace': 'AWS/Lambda',
405 |             'dimensions': {
406 |                 'FunctionName': 'aws_lambda_function.slack_lambda.function_name'
407 |             },
408 |             'threshold': '1',
409 |             'period': '60',
410 |             'statistic': 'Sum',
411 |             'treat_missing_data': 'missing',
412 |             'insufficient_data_actions': [],
413 |             'alarm_actions': ['var.fallback_sns'],
414 |         }
415 | 
416 |         # Act
417 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
418 | 
419 |         # Assert
420 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
421 |         self.assert_resources_match(actual_resources, expected_properties)
422 | 
423 |     def test_slack_webhook_secret(self):
424 |         # Arrange
425 |         expected_number_of_resources = 1
426 |         expected_resource_type = 'aws_secretsmanager_secret'
427 |         expected_resource_name = 'slack_webhook'
428 | 
429 |         expected_properties = {
430 |             'name': 'stdf-alert-pipeline-${var.name}-slack-webhook',
431 |         }
432 | 
433 |         # Act
434 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
435 | 
436 |         # Assert
437 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
438 |         self.assert_resources_match(actual_resources, expected_properties)
439 | 
440 |     def test_basic_execution_slack(self):
441 |         # Arrange
442 |         expected_number_of_resources = 1
443 |         expected_resource_type = 'aws_iam_role_policy_attachment'
444 |         expected_resource_name = 'slack_lambda_basic_execution_role_policy'
445 | 
446 |         expected_properties = {
447 |             'role': 'aws_iam_role.slack_lambda.name',
448 |             'policy_arn': 'data.aws_iam_policy.basic_execution_role_policy.arn'
449 |         }
450 | 
451 |         # Act
452 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
453 | 
454 |         # Assert
455 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
456 |         self.assert_resources_match(actual_resources, expected_properties)
457 | 
458 |     def test_basic_execution_converter(self):
459 |         # Arrange
460 |         expected_number_of_resources = 1
461 |         expected_resource_type = 'aws_iam_role_policy_attachment'
462 |         expected_resource_name = 'converter_lambda_basic_execution_role_policy'
463 | 
464 |         expected_properties = {
465 |             'role': 'aws_iam_role.converter_lambda.name',
466 |             'policy_arn': 'data.aws_iam_policy.basic_execution_role_policy.arn'
467 |         }
468 | 
469 |         # Act
470 |         actual_resources = self.get_resources_by_type_and_name(expected_resource_type, expected_resource_name)
471 | 
472 |         # Assert
473 |         self.assertEqual(len(actual_resources.resource_list), expected_number_of_resources)
474 |         self.assert_resources_match(actual_resources, expected_properties)
475 | 


--------------------------------------------------------------------------------
/test/test_lambda_converter.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import unittest.mock
  3 | import importlib
  4 | import json
  5 | 
  6 | lambda_function = importlib.import_module('lambda_converter.lambda_function')
  7 | 
  8 | 
  9 | class TestGetSubjectAndMessage(unittest.TestCase):
 10 |     def setUp(self):
 11 |         importlib.reload(lambda_function)
 12 | 
 13 |     def test_get_subject_and_message(self):
 14 |         # Arrange
 15 |         expected_message = '{"a": "b"}'
 16 |         expected_subject = 'stdfMessage'
 17 | 
 18 |         expected_event = {
 19 |             'Records': [
 20 |                 {
 21 |                     'EventVersion': '1.0',
 22 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
 23 |                     'EventSource': 'aws:sns',
 24 |                     'Sns': {
 25 |                         'SignatureVersion': '1',
 26 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
 27 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
 28 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
 29 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
 30 |                         'Message': expected_message,
 31 |                         'MessageAttributes': {
 32 |                             'Test': {
 33 |                                 'Type': 'String',
 34 |                                 'Value': 'TestString'
 35 |                             },
 36 |                             'TestBinary': {
 37 |                                 'Type': 'Binary',
 38 |                                 'Value': 'TestBinary'
 39 |                             }
 40 |                         },
 41 |                         'Type': 'Notification',
 42 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
 43 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
 44 |                         'Subject': expected_subject
 45 |                     }
 46 |                 }
 47 |             ]
 48 |         }
 49 | 
 50 |         # Act
 51 |         actual_subject, actual_message = lambda_function.get_subject_and_message(expected_event)
 52 | 
 53 |         # Assert
 54 |         self.assertEqual(actual_subject, expected_subject)
 55 |         self.assertEqual(actual_message, expected_message)
 56 | 
 57 | 
 58 | class TestErrorIfNotExactlyOneRecord(unittest.TestCase):
 59 |     def setUp(self):
 60 |         importlib.reload(lambda_function)
 61 | 
 62 |     def test_error_on_two_records(self):
 63 |         # Arrange
 64 |         expected_number_of_records = 2
 65 |         expected_error = f'Received SNS message with {expected_number_of_records} records. This should never happen: AWS states all lambda SNS messages will always have exactly one record.'
 66 | 
 67 |         expected_event = {
 68 |             'Records': [
 69 |                 'a',
 70 |                 'b'
 71 |             ]
 72 |         }
 73 | 
 74 |         # Act
 75 |         with self.assertRaises(Exception) as actual_exception_context:
 76 |             lambda_function.error_if_not_exactly_one_record(expected_event)
 77 | 
 78 |         # Assert
 79 |         self.assertIn(expected_error, str(actual_exception_context.exception))
 80 | 
 81 |     def test_error_on_zero_records(self):
 82 |         # Arrange
 83 |         expected_number_of_records = 0
 84 |         expected_error = f'Received SNS message with {expected_number_of_records} records. This should never happen: AWS states all lambda SNS messages will always have exactly one record.'
 85 | 
 86 |         expected_event = {
 87 |             'Records': [
 88 |             ]
 89 |         }
 90 | 
 91 |         # Act
 92 |         with self.assertRaises(Exception) as actual_exception_context:
 93 |             lambda_function.error_if_not_exactly_one_record(expected_event)
 94 | 
 95 |         # Assert
 96 |         self.assertIn(expected_error, str(actual_exception_context.exception))
 97 | 
 98 |     def test_no_error_on_one_record(self):
 99 |         # Arrange
100 |         expected_result = None
101 | 
102 |         expected_event = {
103 |             'Records': [
104 |                 'a'
105 |             ]
106 |         }
107 | 
108 |         # Act
109 |         actual_result = lambda_function.error_if_not_exactly_one_record(expected_event)
110 | 
111 |         # Assert
112 |         self.assertEqual(actual_result, expected_result)
113 | 
114 | 
115 | class TestParseMetricToStdf(unittest.TestCase):
116 |     def setUp(self):
117 |         importlib.reload(lambda_function)
118 | 
119 |     def test_parse_metric_to_stdf(self):
120 |         # Arrange
121 |         expected_service_name = 'CloudWatch'
122 |         expected_app_name = 'Metric Alarm'
123 | 
124 |         expected_alarm_name = 'Example alarm name'
125 |         expected_description = 'Example alarm description.'
126 |         expected_account_id = '000000000000'
127 |         expected_region = 'EU - Ireland'
128 |         expected_timestamp = '2017-01-12T16:30:42.236+0000'
129 |         expected_timestamp_milliseconds = 1484238642236
130 |         expected_log_line = 'Threshold Crossed: 1 datapoint (10.0) was greater than or equal to the threshold (1.0).'
131 |         expected_provider = 'AWS'
132 |         expected_message = {
133 |             'AlarmName': expected_alarm_name,
134 |             'AlarmDescription': expected_description,
135 |             'AWSAccountId': expected_account_id,
136 |             'NewStateValue': 'ALARM',
137 |             'NewStateReason': expected_log_line,
138 |             'StateChangeTime': expected_timestamp,
139 |             'Region': expected_region,
140 |             'OldStateValue': 'OK',
141 |             'Trigger': {
142 |                 'MetricName': 'DeliveryErrors',
143 |                 'Namespace': 'ExampleNamespace',
144 |                 'Statistic': 'SUM',
145 |                 'Unit': 'null',
146 |                 'Dimensions': [],
147 |                 'Period': 300,
148 |                 'EvaluationPeriods': 1,
149 |                 'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
150 |                 'Threshold': 1.0
151 |             }
152 |         }
153 |         expected_message_string = json.dumps(expected_message)
154 | 
155 |         expected_urls = [{
156 |             'url': f'https://console.aws.amazon.com/cloudwatch/home#alarmsV2:alarm/{expected_alarm_name}',
157 |             'text': 'Show alarm details'
158 |         }]
159 | 
160 |         expected_stdf_message = {
161 |             'payload': {
162 |                 'title': expected_alarm_name,
163 |                 'description': expected_description,
164 |                 'raw_data': expected_log_line
165 |             },
166 |             'meta': {
167 |                 'timestamp': expected_timestamp_milliseconds,
168 |                 'source': {
169 |                     'provider': expected_provider,
170 |                     'account_id': expected_account_id,
171 |                     'region': expected_region,
172 |                     'service': expected_service_name,
173 |                     'app_name': expected_app_name
174 |                 },
175 |                 'urls': expected_urls
176 |             },
177 |             'stdf_version': 2,
178 |         }
179 |         expected_stdf_string = json.dumps(expected_stdf_message)
180 | 
181 |         # Act
182 |         actual_stdf_string = lambda_function.parse_metric_to_stdf(expected_message_string)
183 | 
184 |         # Assert
185 |         self.assertEqual(actual_stdf_string, expected_stdf_string)
186 | 
187 | 
188 | class TestPostStdfToSns(unittest.TestCase):
189 |     def setUp(self):
190 |         importlib.reload(lambda_function)
191 | 
192 |     @unittest.mock.patch('lambda_converter.lambda_function.boto3.client')
193 |     def test_post_stdf_string_to_sns(self, mock_boto3_client):
194 |         # Arrange
195 |         expected_service_name = 'sns'
196 |         expected_provider = 'AWS'
197 |         expected_stdf_service_name = 'CloudWatch'
198 |         expected_region = 'us-east-1'
199 |         expected_account_id = '123456789012'
200 |         expected_timestamp_milliseconds = 1582154420 * 1000
201 |         expected_log_line = '2020-03-26 08:36:27.000000000  0900 http_logs: {\'host\':\'10.112.250.161\',\'user\':null,\'method\':\'POST\',\'path\':\'/saml/SSO\',\'code\':302,\'size\':null,\'referer\':null,\'agent\':null}'
202 | 
203 |         expected_description = 'Something happened. A lot of things actually so this text is really long. This is a very detailed description innit.'
204 |         expected_app_name = 'Jamf'
205 |         expected_alert_title = 'BambooHR sync failed!!'
206 | 
207 |         expected_stdf_message_json = {
208 |             'payload': {
209 |                 'title': expected_alert_title,
210 |                 'description': expected_description,
211 |                 'raw_data': expected_log_line
212 |             },
213 |             'meta': {
214 |                 'timestamp': expected_timestamp_milliseconds,
215 |                 'source': {
216 |                     'provider': expected_provider,
217 |                     'account_id': expected_account_id,
218 |                     'region': expected_region,
219 |                     'service': expected_stdf_service_name,
220 |                     'app_name': expected_app_name
221 |                 },
222 |             },
223 |             'stdf_version': 2,
224 |         }
225 |         expected_stdf_message = json.dumps(expected_stdf_message_json)
226 | 
227 |         expected_sns_topic = 'topic_name'
228 |         expected_outgoing_subject = f'stdf: {expected_alert_title}'
229 | 
230 |         os.environ['OUTGOING_SNS_TOPIC'] = expected_sns_topic
231 |         mock_sns_client = mock_boto3_client.return_value
232 | 
233 |         # Act
234 |         lambda_function.post_stdf_string_to_sns(expected_stdf_message)
235 | 
236 |         # Assert
237 |         mock_boto3_client.assert_called_once_with(expected_service_name)
238 |         mock_sns_client.publish.assert_called_once_with(
239 |             TopicArn=expected_sns_topic,
240 |             Subject=expected_outgoing_subject,
241 |             Message=expected_stdf_message
242 |         )
243 | 
244 |     @unittest.mock.patch('lambda_converter.lambda_function.boto3.client')
245 |     def test_post_stdf_string_to_sns_long(self, mock_boto3_client):
246 |         # Arrange
247 |         expected_max_subject_length = 99
248 |         expected_service_name = 'sns'
249 |         expected_provider = 'AWS'
250 |         expected_stdf_service_name = 'CloudWatch'
251 |         expected_region = 'us-east-1'
252 |         expected_account_id = '123456789012'
253 |         expected_timestamp_milliseconds = 1582154420 * 1000
254 |         expected_log_line = '2020-03-26 08:36:27.000000000  0900 http_logs: {\'host\':\'10.112.250.161\',\'user\':null,\'method\':\'POST\',\'path\':\'/saml/SSO\',\'code\':302,\'size\':null,\'referer\':null,\'agent\':null}'
255 | 
256 |         expected_description = 'Something happened. A lot of things actually so this text is really long. This is a very detailed description innit.'
257 |         expected_app_name = 'Jamf'
258 |         expected_alert_title = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
259 |         expected_alert_subject = 'stdf: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[TRUNCATED]'
260 | 
261 |         expected_stdf_message_json = {
262 |             'payload': {
263 |                 'title': expected_alert_title,
264 |                 'description': expected_description,
265 |                 'raw_data': expected_log_line
266 |             },
267 |             'meta': {
268 |                 'timestamp': expected_timestamp_milliseconds,
269 |                 'source': {
270 |                     'provider': expected_provider,
271 |                     'account_id': expected_account_id,
272 |                     'region': expected_region,
273 |                     'service': expected_stdf_service_name,
274 |                     'app_name': expected_app_name
275 |                 },
276 |             },
277 |             'stdf_version': 2,
278 |         }
279 |         expected_stdf_message = json.dumps(expected_stdf_message_json)
280 |         expected_sns_topic = 'topic_name'
281 |         expected_outgoing_subject = f'stdf: {expected_alert_title}'[:expected_max_subject_length]
282 | 
283 |         os.environ['OUTGOING_SNS_TOPIC'] = expected_sns_topic
284 |         mock_sns_client = mock_boto3_client.return_value
285 | 
286 |         # Act
287 |         lambda_function.post_stdf_string_to_sns(expected_stdf_message)
288 | 
289 |         # Assert
290 |         mock_boto3_client.assert_called_once_with(expected_service_name)
291 |         mock_sns_client.publish.assert_called_once_with(
292 |             TopicArn=expected_sns_topic,
293 |             Subject=expected_alert_subject,
294 |             Message=expected_stdf_message
295 |         )
296 | 
297 | 
298 | class TestPostUnrecognizedToSns(unittest.TestCase):
299 |     def setUp(self):
300 |         importlib.reload(lambda_function)
301 | 
302 |     @unittest.mock.patch('lambda_converter.lambda_function.boto3.client')
303 |     @unittest.mock.patch('lambda_converter.lambda_function.logging')
304 |     def test_post_unrecognized_to_sns_and_warn(self, mock_logging, mock_boto3_client):
305 |         # Arrange
306 |         expected_service_name = 'sns'
307 |         expected_message = '{"foo": "bar"}'
308 |         expected_sns_topic = 'topic_name'
309 |         expected_event = {}
310 | 
311 |         os.environ['OUTGOING_SNS_TOPIC'] = expected_sns_topic
312 |         mock_sns_client = mock_boto3_client.return_value
313 | 
314 |         expected_logger = 'Unrecognized Message Format'
315 | 
316 |         # Act
317 |         lambda_function.post_unrecognized_to_sns_and_warn(expected_message, expected_event)
318 | 
319 |         # Assert
320 |         mock_boto3_client.assert_called_once_with(expected_service_name)
321 |         mock_sns_client.publish.assert_called_once_with(
322 |             TopicArn=expected_sns_topic,
323 |             Subject='unrecognizedNonStdfMessage',
324 |             Message=expected_message
325 |         )
326 |         mock_logging.getLogger.assert_called_once_with(expected_logger)
327 |         mock_logging.getLogger.return_value.warn.assert_called_once_with(expected_event)
328 | 
329 | 
330 | class TestLambdaHandler(unittest.TestCase):
331 |     def setUp(self):
332 |         importlib.reload(lambda_function)
333 | 
334 |     @unittest.mock.patch('lambda_converter.lambda_function.log_event')
335 |     @unittest.mock.patch('lambda_converter.lambda_function.error_if_not_exactly_one_record')
336 |     @unittest.mock.patch('lambda_converter.lambda_function.get_subject_and_message')
337 |     @unittest.mock.patch('lambda_converter.lambda_function.post_stdf_string_to_sns')
338 |     @unittest.mock.patch('lambda_converter.lambda_function.post_unrecognized_to_sns_and_warn')
339 |     @unittest.mock.patch('lambda_converter.lambda_function.parse_metric_to_stdf')
340 |     def test_handle_incoming_stdf(self, mock_parse_metric_to_stdf, mock_post_unrecognized_to_sns_and_warn, mock_post_stdf_string_to_sns,
341 |                                   mock_get_subject_and_message, mock_error_if_not_exactly_one_record, mock_log_event):
342 |         # Arrange
343 |         expected_message = '{"a": "b"}'
344 |         expected_subject = 'stdfMessage'
345 | 
346 |         expected_context = {}
347 | 
348 |         expected_event = {
349 |             'Records': [
350 |                 {
351 |                     'EventVersion': '1.0',
352 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
353 |                     'EventSource': 'aws:sns',
354 |                     'Sns': {
355 |                         'SignatureVersion': '1',
356 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
357 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
358 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
359 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
360 |                         'Message': expected_message,
361 |                         'MessageAttributes': {
362 |                             'Test': {
363 |                                 'Type': 'String',
364 |                                 'Value': 'TestString'
365 |                             },
366 |                             'TestBinary': {
367 |                                 'Type': 'Binary',
368 |                                 'Value': 'TestBinary'
369 |                             }
370 |                         },
371 |                         'Type': 'Notification',
372 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
373 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
374 |                         'Subject': expected_subject
375 |                     }
376 |                 }
377 |             ]
378 |         }
379 | 
380 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message)
381 | 
382 |         # Act
383 |         lambda_function.lambda_handler(expected_event, expected_context)
384 | 
385 |         # Assert
386 |         mock_log_event.assert_called_once_with(expected_event)
387 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
388 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
389 |         mock_post_stdf_string_to_sns.assert_called_once_with(expected_message)
390 |         mock_post_unrecognized_to_sns_and_warn.assert_not_called()
391 |         mock_parse_metric_to_stdf.assert_not_called()
392 | 
393 |     @unittest.mock.patch('lambda_converter.lambda_function.log_event')
394 |     @unittest.mock.patch('lambda_converter.lambda_function.error_if_not_exactly_one_record')
395 |     @unittest.mock.patch('lambda_converter.lambda_function.get_subject_and_message')
396 |     @unittest.mock.patch('lambda_converter.lambda_function.post_stdf_string_to_sns')
397 |     @unittest.mock.patch('lambda_converter.lambda_function.post_unrecognized_to_sns_and_warn')
398 |     @unittest.mock.patch('lambda_converter.lambda_function.parse_metric_to_stdf')
399 |     def test_handle_incoming_metric_alarm(self, mock_parse_metric_to_stdf, mock_post_unrecognized_to_sns_and_warn, mock_post_stdf_string_to_sns,
400 |                                   mock_get_subject_and_message, mock_error_if_not_exactly_one_record, mock_log_event):
401 |         # Arrange
402 |         expected_subject = 'ALARM: "Example alarm name" in EU - Ireland'
403 |         expected_context = {}
404 |         expected_message = {
405 |             'AlarmName': 'Example alarm name',
406 |             'AlarmDescription': 'Example alarm description.',
407 |             'AWSAccountId': '000000000000',
408 |             'NewStateValue': 'ALARM',
409 |             'NewStateReason': 'Threshold Crossed: 1 datapoint (10.0) was greater than or equal to the threshold (1.0).',
410 |             'StateChangeTime': '2017-01-12T16:30:42.236+0000', 'Region': 'EU - Ireland', 'OldStateValue': 'OK',
411 |             'Trigger': {
412 |                 'MetricName': 'DeliveryErrors',
413 |                 'Namespace': 'ExampleNamespace',
414 |                 'Statistic': 'SUM',
415 |                 'Unit': 'null',
416 |                 'Dimensions': [],
417 |                 'Period': 300,
418 |                 'EvaluationPeriods': 1,
419 |                 'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
420 |                 'Threshold': 1.0
421 |             }
422 |         }
423 |         expected_message_string = json.dumps(expected_message)
424 |         expected_metric_alarm = {
425 |             'Message': expected_message_string,
426 |             'Subject': expected_subject
427 |         }
428 |         expected_event = {
429 |             'Records': [
430 |                 {
431 |                     'EventVersion': '1.0',
432 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
433 |                     'EventSource': 'aws:sns',
434 |                     'Sns': expected_metric_alarm
435 |                 }
436 |             ]
437 |         }
438 |         expected_stdf_message_string = '{"stdf": 2}'
439 | 
440 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message_string)
441 |         mock_parse_metric_to_stdf.return_value = expected_stdf_message_string
442 | 
443 |         # Act
444 |         lambda_function.lambda_handler(expected_event, expected_context)
445 | 
446 |         # Assert
447 |         mock_log_event.assert_called_once_with(expected_event)
448 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
449 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
450 |         mock_post_stdf_string_to_sns.assert_called_once_with(expected_stdf_message_string)
451 |         mock_parse_metric_to_stdf.assert_called_once_with(expected_message_string)
452 |         mock_post_unrecognized_to_sns_and_warn.assert_not_called()
453 | 
454 |     @unittest.mock.patch('lambda_converter.lambda_function.log_event')
455 |     @unittest.mock.patch('lambda_converter.lambda_function.error_if_not_exactly_one_record')
456 |     @unittest.mock.patch('lambda_converter.lambda_function.get_subject_and_message')
457 |     @unittest.mock.patch('lambda_converter.lambda_function.post_stdf_string_to_sns')
458 |     @unittest.mock.patch('lambda_converter.lambda_function.post_unrecognized_to_sns_and_warn')
459 |     @unittest.mock.patch('lambda_converter.lambda_function.parse_metric_to_stdf')
460 |     def test_handle_incoming_unrecognized(self, mock_parse_metric_to_stdf, mock_post_unrecognized_to_sns_and_warn, mock_post_stdf_string_to_sns,
461 |                                           mock_get_subject_and_message, mock_error_if_not_exactly_one_record, mock_log_event):
462 |         # Arrange
463 |         expected_message = '{"a": "b"}'
464 |         expected_subject = 'unrecognizedMessage'
465 | 
466 |         expected_context = {}
467 | 
468 |         expected_event = {
469 |             'Records': [
470 |                 {
471 |                     'EventVersion': '1.0',
472 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
473 |                     'EventSource': 'aws:sns',
474 |                     'Sns': {
475 |                         'SignatureVersion': '1',
476 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
477 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
478 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
479 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
480 |                         'Message': expected_message,
481 |                         'MessageAttributes': {
482 |                             'Test': {
483 |                                 'Type': 'String',
484 |                                 'Value': 'TestString'
485 |                             },
486 |                             'TestBinary': {
487 |                                 'Type': 'Binary',
488 |                                 'Value': 'TestBinary'
489 |                             }
490 |                         },
491 |                         'Type': 'Notification',
492 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
493 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
494 |                         'Subject': expected_subject
495 |                     }
496 |                 }
497 |             ]
498 |         }
499 | 
500 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message)
501 | 
502 |         # Act
503 |         lambda_function.lambda_handler(expected_event, expected_context)
504 | 
505 |         # Assert
506 |         mock_log_event.assert_called_once_with(expected_event)
507 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
508 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
509 |         mock_post_unrecognized_to_sns_and_warn.assert_called_once_with(expected_message, expected_event)
510 |         mock_post_stdf_string_to_sns.assert_not_called()
511 |         mock_parse_metric_to_stdf.assert_not_called()
512 | 


--------------------------------------------------------------------------------
/test/test_lambda_slack.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import unittest.mock
  3 | import importlib
  4 | import json
  5 | import http
  6 | 
  7 | lambda_function = importlib.import_module('lambda_slack.lambda_function')
  8 | 
  9 | 
 10 | class TestGetSubjectAndMessage(unittest.TestCase):
 11 |     def setUp(self):
 12 |         importlib.reload(lambda_function)
 13 | 
 14 |     def test_get_subject_and_message(self):
 15 |         # Arrange
 16 |         expected_message = '{"a": "b"}'
 17 |         expected_subject = 'stdfMessage'
 18 | 
 19 |         expected_event = {
 20 |             'Records': [
 21 |                 {
 22 |                     'EventVersion': '1.0',
 23 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
 24 |                     'EventSource': 'aws:sns',
 25 |                     'Sns': {
 26 |                         'SignatureVersion': '1',
 27 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
 28 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
 29 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
 30 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
 31 |                         'Message': expected_message,
 32 |                         'MessageAttributes': {
 33 |                             'Test': {
 34 |                                 'Type': 'String',
 35 |                                 'Value': 'TestString'
 36 |                             },
 37 |                             'TestBinary': {
 38 |                                 'Type': 'Binary',
 39 |                                 'Value': 'TestBinary'
 40 |                             }
 41 |                         },
 42 |                         'Type': 'Notification',
 43 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
 44 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
 45 |                         'Subject': expected_subject
 46 |                     }
 47 |                 }
 48 |             ]
 49 |         }
 50 | 
 51 |         # Act
 52 |         actual_subject, actual_message = lambda_function.get_subject_and_message(expected_event)
 53 | 
 54 |         # Assert
 55 |         self.assertEqual(actual_subject, expected_subject)
 56 |         self.assertEqual(actual_message, expected_message)
 57 | 
 58 | 
 59 | class TestErrorIfNotExactlyOneRecord(unittest.TestCase):
 60 |     def setUp(self):
 61 |         importlib.reload(lambda_function)
 62 | 
 63 |     def test_error_on_two_records(self):
 64 |         # Arrange
 65 |         expected_number_of_records = 2
 66 |         expected_error = f'Received SNS message with {expected_number_of_records} records. This should never happen: AWS states all lambda SNS messages will always have exactly one record.'
 67 | 
 68 |         expected_event = {
 69 |             'Records': [
 70 |                 'a',
 71 |                 'b'
 72 |             ]
 73 |         }
 74 | 
 75 |         # Act
 76 |         with self.assertRaises(Exception) as actual_exception_context:
 77 |             lambda_function.error_if_not_exactly_one_record(expected_event)
 78 | 
 79 |         # Assert
 80 |         self.assertIn(expected_error, str(actual_exception_context.exception))
 81 | 
 82 |     def test_error_on_zero_records(self):
 83 |         # Arrange
 84 |         expected_number_of_records = 0
 85 |         expected_error = f'Received SNS message with {expected_number_of_records} records. This should never happen: AWS states all lambda SNS messages will always have exactly one record.'
 86 | 
 87 |         expected_event = {
 88 |             'Records': [
 89 |             ]
 90 |         }
 91 | 
 92 |         # Act
 93 |         with self.assertRaises(Exception) as actual_exception_context:
 94 |             lambda_function.error_if_not_exactly_one_record(expected_event)
 95 | 
 96 |         # Assert
 97 |         self.assertIn(expected_error, str(actual_exception_context.exception))
 98 | 
 99 |     def test_no_error_on_one_record(self):
100 |         # Arrange
101 |         expected_result = None
102 | 
103 |         expected_event = {
104 |             'Records': [
105 |                 'a'
106 |             ]
107 |         }
108 | 
109 |         # Act
110 |         actual_result = lambda_function.error_if_not_exactly_one_record(expected_event)
111 | 
112 |         # Assert
113 |         self.assertEqual(actual_result, expected_result)
114 | 
115 | 
116 | class TestGetWebhook(unittest.TestCase):
117 |     def setUp(self):
118 |         os.environ.clear()
119 |         importlib.reload(lambda_function)
120 | 
121 |     @unittest.mock.patch('boto3.client')
122 |     def test_get_webhook(self, mock_boto3_client):
123 |         # Arrange
124 |         expected_service_name = 'secretsmanager'
125 |         expected_webhook = {
126 |             'host': 'hooks.slack.com',
127 |             'path': '/services/00000000000/AAAAAAAAAa/XXXXXXXXXXX'
128 |         }
129 |         expected_webhook_dumped = json.dumps(expected_webhook)
130 |         expected_slack_webhook_secret_id = 'the-webhook-stuff-lives-here'
131 |         expected_secretsmanager_response = {
132 |             'ARN': 'string',
133 |             'Name': 'string',
134 |             'VersionId': 'string',
135 |             'SecretBinary': 'bytes',
136 |             'SecretString': expected_webhook_dumped,
137 |             'VersionStages': [
138 |                 'string',
139 |             ],
140 |             'CreatedDate': '13231312312'
141 |         }
142 | 
143 |         os.environ['SLACK_WEBHOOK_SECRET_ID'] = expected_slack_webhook_secret_id
144 | 
145 |         mock_secretsmanager_client = mock_boto3_client.return_value
146 |         mock_secretsmanager_client.get_secret_value.return_value = expected_secretsmanager_response
147 | 
148 |         # Act
149 |         actual_webhook = lambda_function.get_webhook()
150 | 
151 |         # Assert
152 |         self.assertEqual(actual_webhook, expected_webhook)
153 |         mock_boto3_client.assert_called_once_with(expected_service_name)
154 |         mock_secretsmanager_client.get_secret_value.assert_called_once_with(SecretId=expected_slack_webhook_secret_id)
155 | 
156 | 
157 | class TestPostToSlack(unittest.TestCase):
158 |     def setUp(self):
159 |         importlib.reload(lambda_function)
160 | 
161 |     @unittest.mock.patch('http.client')
162 |     def test_post_to_slack(self, mock_http_client):
163 |         # Arrange
164 |         expected_https_port = 443
165 |         expected_webhook_host = 'hooks.slack.com'
166 |         expected_webhook_path = '/services/00000000000/AAAAAAAAAa/XXXXXXXXXXX'
167 |         expected_headers = {
168 |             'Content-Type': 'application/json'
169 |         }
170 |         expected_method = 'POST'
171 |         expected_slack_message = {'bunch': 'of_slack_blocks'}
172 |         expected_dumped_slack_message = json.dumps(expected_slack_message)
173 | 
174 |         expected_webhook = {
175 |             'host': expected_webhook_host,
176 |             'path': expected_webhook_path
177 |         }
178 | 
179 |         mock_conn = mock_http_client.HTTPSConnection.return_value
180 |         mock_conn.getresponse.return_value.status = http.HTTPStatus.OK
181 | 
182 |         # Act
183 |         lambda_function.post_to_slack(expected_webhook, expected_slack_message)
184 | 
185 |         # Assert
186 |         mock_http_client.HTTPSConnection.assert_called_once_with(expected_webhook_host, expected_https_port)
187 |         mock_conn.request.assert_called_once_with(
188 |             expected_method,
189 |             expected_webhook_path,
190 |             body=expected_dumped_slack_message,
191 |             headers=expected_headers
192 |         )
193 | 
194 |     @unittest.mock.patch('http.client')
195 |     def test_post_to_slack_errored(self, mock_http_client):
196 |         # Arrange
197 |         expected_https_port = 443
198 |         expected_webhook_host = "hooks.slack.com"
199 |         expected_webhook_path = "/services/00000000000/AAAAAAAAAa/XXXXXXXXXXX"
200 |         expected_headers = {
201 |             'Content-Type': 'application/json'
202 |         }
203 |         expected_method = 'POST'
204 |         expected_slack_message = {'bunch': 'of_slack_blocks'}
205 |         expected_status = http.HTTPStatus.BAD_REQUEST
206 |         expected_error = f"Request to slack returned an error {expected_status}"
207 | 
208 |         expected_webhook = {
209 |             "host": expected_webhook_host,
210 |             "path": expected_webhook_path
211 |         }
212 | 
213 |         mock_conn = mock_http_client.HTTPSConnection.return_value
214 |         mock_conn.getresponse.return_value.status = expected_status
215 | 
216 |         # Act
217 |         with self.assertRaises(Exception) as actual_exception_context:
218 |             lambda_function.post_to_slack(expected_webhook, expected_slack_message)
219 | 
220 |         # Assert
221 |         mock_http_client.HTTPSConnection.assert_called_once_with(expected_webhook_host, expected_https_port)
222 |         mock_conn.request(expected_method, expected_webhook_path, expected_slack_message, expected_headers)
223 |         self.assertIn(expected_error, str(actual_exception_context.exception))
224 | 
225 | 
226 | class TestFormatUrls(unittest.TestCase):
227 |     def setUp(self):
228 |         importlib.reload(lambda_function)
229 | 
230 |     def test_format_urls_singe_url(self):
231 |         # Arrange
232 |         expected_url_1 = {
233 |             'url': 'http://example.com',
234 |             'text': 'click this'
235 |         }
236 | 
237 |         expected_urls = [expected_url_1]
238 |         expected_formatted_urls = f"<{expected_url_1['url']}|{expected_url_1['text']}>"
239 | 
240 |         # Act
241 |         actual_formatted_urls = lambda_function.format_urls(expected_urls)
242 | 
243 |         # Assert
244 |         self.assertEqual(actual_formatted_urls, expected_formatted_urls)
245 | 
246 |     def test_format_urls_2_urls(self):
247 |         # Arrange
248 |         expected_url_1 = {
249 |             'url': 'http://example.com',
250 |             'text': 'click this'
251 |         }
252 |         expected_url_2 = {
253 |             'url': 'http://corona.com',
254 |             'text': 'virus'
255 |         }
256 | 
257 |         expected_urls = [expected_url_1, expected_url_2]
258 |         expected_formatted_urls = f"<{expected_url_1['url']}|{expected_url_1['text']}> - <{expected_url_2['url']}|{expected_url_2['text']}>"
259 | 
260 |         # Act
261 |         actual_formatted_urls = lambda_function.format_urls(expected_urls)
262 | 
263 |         # Assert
264 |         self.assertEqual(actual_formatted_urls, expected_formatted_urls)
265 | 
266 |     def test_format_urls_multi_urls(self):
267 |         # Arrange
268 |         expected_url_1 = {
269 |             'url': 'http://example.com',
270 |             'text': 'click this'
271 |         }
272 |         expected_url_2 = {
273 |             'url': 'http://corona.com',
274 |             'text': 'virus'
275 |         }
276 |         expected_url_3 = {
277 |             'url': 'http://nintendo.com',
278 |             'text': 'switch'
279 |         }
280 | 
281 |         expected_urls = [expected_url_1, expected_url_2, expected_url_3]
282 |         expected_formatted_urls = f"<{expected_url_1['url']}|{expected_url_1['text']}> - <{expected_url_2['url']}|{expected_url_2['text']}> - <{expected_url_3['url']}|{expected_url_3['text']}>"
283 | 
284 |         # Act
285 |         actual_formatted_urls = lambda_function.format_urls(expected_urls)
286 | 
287 |         # Assert
288 |         self.assertEqual(actual_formatted_urls, expected_formatted_urls)
289 | 
290 | 
291 | class TestGetZuluTime(unittest.TestCase):
292 |     def setUp(self):
293 |         importlib.reload(lambda_function)
294 | 
295 |     def test_get_zulu_timestamp(self):
296 |         # Arrange
297 |         expected_timestamp_milliseconds = 1582154420 * 1000
298 |         expected_zulu_timestamp = '2020-02-19T23:20:20Z'
299 | 
300 |         # Act
301 |         actual_zulu_timestamp = lambda_function.get_zulu_timestamp(expected_timestamp_milliseconds)
302 | 
303 |         # Assert
304 |         self.assertEqual(actual_zulu_timestamp, expected_zulu_timestamp)
305 | 
306 | 
307 | class TestFormatStdf(unittest.TestCase):
308 |     def setUp(self):
309 |         importlib.reload(lambda_function)
310 | 
311 |     @unittest.mock.patch('lambda_slack.lambda_function.get_zulu_timestamp')
312 |     @unittest.mock.patch('lambda_slack.lambda_function.format_urls')
313 |     def test_format_stdf_happy_path(self, mock_format_urls, mock_get_zulu_timestamp):
314 |         # Arrange
315 |         expected_event_id = '000000000000000000000000000000000000000000000'
316 |         expected_provider = 'AWS'
317 |         expected_service_name = 'CloudWatch'
318 |         expected_region = 'us-east-1'
319 |         expected_account_id = '123456789012'
320 |         expected_timestamp_zulu = '2020-02-20T02:20:20Z'
321 |         mock_get_zulu_timestamp.return_value = expected_timestamp_zulu
322 |         expected_timestamp_milliseconds = 1582154420 * 1000
323 |         expected_log_line = '2020-03-26 08:36:27.000000000  0900 http_logs: {\'host\':\'10.112.250.161\',\'user\':null,\'method\':\'POST\',\'path\':\'/saml/SSO\',\'code\':302,\'size\':null,\'referer\':null,\'agent\':null}'
324 | 
325 |         expected_description = 'Something happened. A lot of things actually so this text is really long. This is a very detailed description innit.'
326 |         expected_app_name = 'Jamf'
327 |         expected_alert_title = 'BambooHR sync failed'
328 | 
329 |         expected_url_1 = {
330 |             'url': 'http://example.com',
331 |             'text': 'click this'
332 |         }
333 |         expected_url_2 = {
334 |             'url': 'http://that.com',
335 |             'text': 'click that'
336 |         }
337 | 
338 |         expected_links = f"<{expected_url_1['url']}|{expected_url_1['text']}> - <{expected_url_2['url']}|{expected_url_2['text']}>"
339 |         mock_format_urls.return_value = expected_links
340 | 
341 |         expected_formatted_message = {
342 |             'blocks': [
343 |                 {
344 |                     'type': 'section',
345 |                     'text': {
346 |                         'type': 'mrkdwn',
347 |                         'text': f'*{expected_app_name}*: *{expected_alert_title}*'
348 |                     }
349 |                 },
350 |                 {
351 |                     'type': 'section',
352 |                     'text': {
353 |                         'type': 'mrkdwn',
354 |                         'text': expected_description
355 |                     }
356 |                 },
357 |                 {
358 |                     'type': 'section',
359 |                     'text': {
360 |                         'type': 'mrkdwn',
361 |                         'text': f'```{expected_log_line}```'
362 |                     }
363 |                 },
364 |                 {
365 |                     'type': 'divider'
366 |                 },
367 |                 {
368 |                     'type': 'section',
369 |                     'fields': [
370 |                         {
371 |                             'type': 'mrkdwn',
372 |                             'text': f'*Source:* {expected_provider} {expected_service_name}'
373 |                         },
374 |                         {
375 |                             'type': 'mrkdwn',
376 |                             'text': f'*Account id:* {expected_account_id}'
377 |                         },
378 |                         {
379 |                             'type': 'mrkdwn',
380 |                             'text': f'*Timestamp*: {expected_timestamp_zulu}'
381 |                         },
382 |                         {
383 |                             'type': 'mrkdwn',
384 |                             'text': '*Region:* us-east-1'
385 |                         }
386 |                     ]
387 |                 },
388 |                 {
389 |                     'type': 'divider'
390 |                 },
391 |                 {
392 |                     'type': 'section',
393 |                     'text': {
394 |                         'type': 'mrkdwn',
395 |                         'text': expected_links
396 |                     }
397 |                 },
398 |                 {
399 |                     'type': 'context',
400 |                     'elements': [
401 |                         {
402 |                             'type': 'mrkdwn',
403 |                             'text': f'*Event id*: {expected_event_id}'
404 |                         }
405 |                     ]
406 |                 }
407 |             ]
408 |         }
409 | 
410 |         expected_urls = [
411 |             expected_url_1,
412 |             expected_url_2
413 |         ]
414 | 
415 |         expected_stdf_message = {
416 |             'payload': {
417 |                 'title': expected_alert_title,
418 |                 'description': expected_description,
419 |                 'raw_data': expected_log_line
420 |             },
421 |             'meta': {
422 |                 'timestamp': expected_timestamp_milliseconds,
423 |                 'source': {
424 |                     'provider': expected_provider,
425 |                     'account_id': expected_account_id,
426 |                     'region': expected_region,
427 |                     'service': expected_service_name,
428 |                     'event_id': expected_event_id,
429 |                     'app_name': expected_app_name
430 |                 },
431 |                 'urls': expected_urls
432 |             },
433 |             'stdf_version': 2,
434 |         }
435 | 
436 |         expected_stdf_message_raw = json.dumps(expected_stdf_message)
437 | 
438 |         # Act
439 |         actual_formatted_message = lambda_function.format_stdf(expected_stdf_message_raw)
440 | 
441 |         # Assert
442 |         self.assertEqual(actual_formatted_message, expected_formatted_message)
443 |         mock_format_urls.assert_called_once_with(expected_urls)
444 |         mock_get_zulu_timestamp.assert_called_once_with(expected_timestamp_milliseconds)
445 | 
446 |     @unittest.mock.patch('lambda_slack.lambda_function.get_zulu_timestamp')
447 |     @unittest.mock.patch('lambda_slack.lambda_function.format_urls')
448 |     def test_format_stdf_no_urls_provided(self, mock_format_urls, mock_get_zulu_timestamp):
449 |         # Arrange
450 |         expected_event_id = '000000000000000000000000000000000000000000000'
451 |         expected_provider = 'AWS'
452 |         expected_service_name = 'CloudWatch'
453 |         expected_region = 'us-east-1'
454 |         expected_account_id = '123456789012'
455 |         expected_timestamp_zulu = '2020-02-20T02:20:20Z'
456 |         mock_get_zulu_timestamp.return_value = expected_timestamp_zulu
457 |         expected_timestamp_milliseconds = 1582154420 * 1000
458 |         expected_log_line = '2020-03-26 08:36:27.000000000  0900 http_logs: {\'host\':\'10.112.250.161\',\'user\':null,\'method\':\'POST\',\'path\':\'/saml/SSO\',\'code\':302,\'size\':null,\'referer\':null,\'agent\':null}'
459 | 
460 |         expected_description = 'Something happened. A lot of things actually so this text is really long. This is a very detailed description innit.'
461 |         expected_app_name = 'Jamf'
462 |         expected_alert_title = 'BambooHR sync failed'
463 | 
464 |         expected_formatted_message = {
465 |             'blocks': [
466 |                 {
467 |                     'type': 'section',
468 |                     'text': {
469 |                         'type': 'mrkdwn',
470 |                         'text': f'*{expected_app_name}*: *{expected_alert_title}*'
471 |                     }
472 |                 },
473 |                 {
474 |                     'type': 'section',
475 |                     'text': {
476 |                         'type': 'mrkdwn',
477 |                         'text': expected_description
478 |                     }
479 |                 },
480 |                 {
481 |                     'type': 'section',
482 |                     'text': {
483 |                         'type': 'mrkdwn',
484 |                         'text': f'```{expected_log_line}```'
485 |                     }
486 |                 },
487 |                 {
488 |                     'type': 'divider'
489 |                 },
490 |                 {
491 |                     'type': 'section',
492 |                     'fields': [
493 |                         {
494 |                             'type': 'mrkdwn',
495 |                             'text': f'*Source:* {expected_provider} {expected_service_name}'
496 |                         },
497 |                         {
498 |                             'type': 'mrkdwn',
499 |                             'text': f'*Account id:* {expected_account_id}'
500 |                         },
501 |                         {
502 |                             'type': 'mrkdwn',
503 |                             'text': f'*Timestamp*: {expected_timestamp_zulu}'
504 |                         },
505 |                         {
506 |                             'type': 'mrkdwn',
507 |                             'text': '*Region:* us-east-1'
508 |                         }
509 |                     ]
510 |                 },
511 |                 {
512 |                     'type': 'divider'
513 |                 },
514 |                 {
515 |                     'type': 'context',
516 |                     'elements': [
517 |                         {
518 |                             'type': 'mrkdwn',
519 |                             'text': f'*Event id*: {expected_event_id}'
520 |                         }
521 |                     ]
522 |                 }
523 |             ]
524 |         }
525 | 
526 |         expected_stdf_message = {
527 |             'payload': {
528 |                 'title': expected_alert_title,
529 |                 'description': expected_description,
530 |                 'raw_data': expected_log_line
531 |             },
532 |             'meta': {
533 |                 'timestamp': expected_timestamp_milliseconds,
534 |                 'source': {
535 |                     'provider': expected_provider,
536 |                     'account_id': expected_account_id,
537 |                     'region': expected_region,
538 |                     'service': expected_service_name,
539 |                     'event_id': expected_event_id,
540 |                     'app_name': expected_app_name
541 |                 },
542 |             },
543 |             'stdf_version': 2,
544 |         }
545 | 
546 |         expected_stdf_message_raw = json.dumps(expected_stdf_message)
547 | 
548 |         # Act
549 |         actual_formatted_message = lambda_function.format_stdf(expected_stdf_message_raw)
550 | 
551 |         # Assert
552 |         self.assertEqual(actual_formatted_message, expected_formatted_message)
553 |         mock_format_urls.assert_not_called()
554 |         mock_get_zulu_timestamp.assert_called_once_with(expected_timestamp_milliseconds)
555 | 
556 |     @unittest.mock.patch('lambda_slack.lambda_function.get_zulu_timestamp')
557 |     @unittest.mock.patch('lambda_slack.lambda_function.format_urls')
558 |     def test_format_stdf_no_urls_no_event_id_provided(self, mock_format_urls, mock_get_zulu_timestamp):
559 |         # Arrange
560 |         expected_provider = 'AWS'
561 |         expected_service_name = 'CloudWatch'
562 |         expected_region = 'us-east-1'
563 |         expected_account_id = '123456789012'
564 |         expected_timestamp_zulu = '2020-02-20T02:20:20Z'
565 |         mock_get_zulu_timestamp.return_value = expected_timestamp_zulu
566 |         expected_timestamp_milliseconds = 1582154420 * 1000
567 |         expected_log_line = '2020-03-26 08:36:27.000000000  0900 http_logs: {\'host\':\'10.112.250.161\',\'user\':null,\'method\':\'POST\',\'path\':\'/saml/SSO\',\'code\':302,\'size\':null,\'referer\':null,\'agent\':null}'
568 | 
569 |         expected_description = 'Something happened. A lot of things actually so this text is really long. This is a very detailed description innit.'
570 |         expected_app_name = 'Jamf'
571 |         expected_alert_title = 'BambooHR sync failed'
572 | 
573 |         expected_formatted_message = {
574 |             'blocks': [
575 |                 {
576 |                     'type': 'section',
577 |                     'text': {
578 |                         'type': 'mrkdwn',
579 |                         'text': f'*{expected_app_name}*: *{expected_alert_title}*'
580 |                     }
581 |                 },
582 |                 {
583 |                     'type': 'section',
584 |                     'text': {
585 |                         'type': 'mrkdwn',
586 |                         'text': expected_description
587 |                     }
588 |                 },
589 |                 {
590 |                     'type': 'section',
591 |                     'text': {
592 |                         'type': 'mrkdwn',
593 |                         'text': f'```{expected_log_line}```'
594 |                     }
595 |                 },
596 |                 {
597 |                     'type': 'divider'
598 |                 },
599 |                 {
600 |                     'type': 'section',
601 |                     'fields': [
602 |                         {
603 |                             'type': 'mrkdwn',
604 |                             'text': f'*Source:* {expected_provider} {expected_service_name}'
605 |                         },
606 |                         {
607 |                             'type': 'mrkdwn',
608 |                             'text': f'*Account id:* {expected_account_id}'
609 |                         },
610 |                         {
611 |                             'type': 'mrkdwn',
612 |                             'text': f'*Timestamp*: {expected_timestamp_zulu}'
613 |                         },
614 |                         {
615 |                             'type': 'mrkdwn',
616 |                             'text': '*Region:* us-east-1'
617 |                         }
618 |                     ]
619 |                 },
620 |                 {
621 |                     'type': 'divider'
622 |                 },
623 |             ]
624 |         }
625 | 
626 |         expected_stdf_message = {
627 |             'payload': {
628 |                 'title': expected_alert_title,
629 |                 'description': expected_description,
630 |                 'raw_data': expected_log_line
631 |             },
632 |             'meta': {
633 |                 'timestamp': expected_timestamp_milliseconds,
634 |                 'source': {
635 |                     'provider': expected_provider,
636 |                     'account_id': expected_account_id,
637 |                     'region': expected_region,
638 |                     'service': expected_service_name,
639 |                     'app_name': expected_app_name
640 |                 },
641 |             },
642 |             'stdf_version': 2,
643 |         }
644 | 
645 |         expected_stdf_message_raw = json.dumps(expected_stdf_message)
646 | 
647 |         # Act
648 |         actual_formatted_message = lambda_function.format_stdf(expected_stdf_message_raw)
649 | 
650 |         # Assert
651 |         self.assertEqual(actual_formatted_message, expected_formatted_message)
652 |         mock_format_urls.assert_not_called()
653 |         mock_get_zulu_timestamp.assert_called_once_with(expected_timestamp_milliseconds)
654 | 
655 | 
656 | class TestFormatFallBack(unittest.TestCase):
657 |     def setUp(self):
658 |         importlib.reload(lambda_function)
659 | 
660 |     def test_format_fallback(self):
661 |         # Arrange
662 |         expected_message = 'raw hardcore log message'
663 |         expected_fallback_reason = 'parsing error'
664 |         expected_text = f'{expected_fallback_reason}. Failed to format the message. Using fallback mode!\n{expected_message}'
665 |         expected_fallback_message = {
666 |             'text': expected_text
667 |         }
668 | 
669 |         # Act
670 |         actual_fallback_message = lambda_function.format_fallback(expected_message, expected_fallback_reason)
671 | 
672 |         # Assert
673 |         self.assertEqual(actual_fallback_message, expected_fallback_message)
674 | 
675 | 
676 | class TestLambdaHandler(unittest.TestCase):
677 |     def setUp(self):
678 |         importlib.reload(lambda_function)
679 | 
680 |     @unittest.mock.patch('lambda_slack.lambda_function.error_if_not_exactly_one_record')
681 |     @unittest.mock.patch('lambda_slack.lambda_function.get_subject_and_message')
682 |     @unittest.mock.patch('lambda_slack.lambda_function.get_webhook')
683 |     @unittest.mock.patch('lambda_slack.lambda_function.format_stdf')
684 |     @unittest.mock.patch('lambda_slack.lambda_function.format_fallback')
685 |     @unittest.mock.patch('lambda_slack.lambda_function.post_to_slack')
686 |     def test_handle_incoming_stdf(self, mock_post_to_slack, mock_format_fallback, mock_format_stdf, mock_get_webhook,
687 |                                   mock_get_subject_and_message, mock_error_if_not_exactly_one_record):
688 |         # Arrange
689 |         expected_message = '{"a": "b"}'
690 |         expected_subject = 'stdfMessage'
691 |         expected_slack_message = 'slackmessage'
692 |         expected_webhook = {
693 |             'host': 'http://a.a',
694 |             'path': '/a/b/c'
695 |         }
696 | 
697 |         expected_context = {}
698 | 
699 |         expected_event = {
700 |             'Records': [
701 |                 {
702 |                     'EventVersion': '1.0',
703 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
704 |                     'EventSource': 'aws:sns',
705 |                     'Sns': {
706 |                         'SignatureVersion': '1',
707 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
708 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
709 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
710 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
711 |                         'Message': expected_message,
712 |                         'MessageAttributes': {
713 |                             'Test': {
714 |                                 'Type': 'String',
715 |                                 'Value': 'TestString'
716 |                             },
717 |                             'TestBinary': {
718 |                                 'Type': 'Binary',
719 |                                 'Value': 'TestBinary'
720 |                             }
721 |                         },
722 |                         'Type': 'Notification',
723 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
724 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
725 |                         'Subject': expected_subject
726 |                     }
727 |                 }
728 |             ]
729 |         }
730 | 
731 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message)
732 |         mock_get_webhook.return_value = expected_webhook
733 |         mock_format_stdf.return_value = expected_slack_message
734 | 
735 |         # Act
736 |         lambda_function.lambda_handler(expected_event, expected_context)
737 | 
738 |         # Assert
739 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
740 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
741 |         mock_get_webhook.assert_called_once()
742 |         mock_format_stdf.assert_called_once_with(expected_message)
743 |         mock_post_to_slack.assert_called_once_with(expected_webhook, expected_slack_message)
744 |         mock_format_fallback.assert_not_called()
745 | 
746 |     @unittest.mock.patch('lambda_slack.lambda_function.error_if_not_exactly_one_record')
747 |     @unittest.mock.patch('lambda_slack.lambda_function.get_subject_and_message')
748 |     @unittest.mock.patch('lambda_slack.lambda_function.get_webhook')
749 |     @unittest.mock.patch('lambda_slack.lambda_function.format_stdf')
750 |     @unittest.mock.patch('lambda_slack.lambda_function.format_fallback')
751 |     @unittest.mock.patch('lambda_slack.lambda_function.post_to_slack')
752 |     def test_handle_incoming_stdf_extended(self, mock_post_to_slack, mock_format_fallback, mock_format_stdf, mock_get_webhook,
753 |                                   mock_get_subject_and_message, mock_error_if_not_exactly_one_record):
754 |         # Arrange
755 |         expected_message = '{"a": "b"}'
756 |         expected_subject = 'stdf: some alert happened!'
757 |         expected_slack_message = 'slackmessage'
758 |         expected_webhook = {
759 |             'host': 'http://a.a',
760 |             'path': '/a/b/c'
761 |         }
762 | 
763 |         expected_context = {}
764 | 
765 |         expected_event = {
766 |             'Records': [
767 |                 {
768 |                     'EventVersion': '1.0',
769 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
770 |                     'EventSource': 'aws:sns',
771 |                     'Sns': {
772 |                         'SignatureVersion': '1',
773 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
774 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
775 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
776 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
777 |                         'Message': expected_message,
778 |                         'MessageAttributes': {
779 |                             'Test': {
780 |                                 'Type': 'String',
781 |                                 'Value': 'TestString'
782 |                             },
783 |                             'TestBinary': {
784 |                                 'Type': 'Binary',
785 |                                 'Value': 'TestBinary'
786 |                             }
787 |                         },
788 |                         'Type': 'Notification',
789 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
790 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
791 |                         'Subject': expected_subject
792 |                     }
793 |                 }
794 |             ]
795 |         }
796 | 
797 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message)
798 |         mock_get_webhook.return_value = expected_webhook
799 |         mock_format_stdf.return_value = expected_slack_message
800 | 
801 |         # Act
802 |         lambda_function.lambda_handler(expected_event, expected_context)
803 | 
804 |         # Assert
805 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
806 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
807 |         mock_get_webhook.assert_called_once()
808 |         mock_format_stdf.assert_called_once_with(expected_message)
809 |         mock_post_to_slack.assert_called_once_with(expected_webhook, expected_slack_message)
810 |         mock_format_fallback.assert_not_called()
811 | 
812 | 
813 |     @unittest.mock.patch('lambda_slack.lambda_function.error_if_not_exactly_one_record')
814 |     @unittest.mock.patch('lambda_slack.lambda_function.get_subject_and_message')
815 |     @unittest.mock.patch('lambda_slack.lambda_function.get_webhook')
816 |     @unittest.mock.patch('lambda_slack.lambda_function.format_stdf')
817 |     @unittest.mock.patch('lambda_slack.lambda_function.format_fallback')
818 |     @unittest.mock.patch('lambda_slack.lambda_function.post_to_slack')
819 |     def test_handle_incoming_unknown(self, mock_post_to_slack, mock_format_fallback, mock_format_stdf, mock_get_webhook,
820 |                                      mock_get_subject_and_message, mock_error_if_not_exactly_one_record):
821 |         # Arrange
822 |         expected_message = '{"a": "b"}'
823 |         expected_subject = 'unknownMessage'
824 |         expected_slack_message = 'slackmessage'
825 |         expected_slack_message_fallback = 'fallbackmessage'
826 |         expected_webhook = {
827 |             'host': 'http://a.a',
828 |             'path': '/a/b/c'
829 |         }
830 | 
831 |         expected_context = {}
832 | 
833 |         expected_event = {
834 |             'Records': [
835 |                 {
836 |                     'EventVersion': '1.0',
837 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
838 |                     'EventSource': 'aws:sns',
839 |                     'Sns': {
840 |                         'SignatureVersion': '1',
841 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
842 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
843 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
844 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
845 |                         'Message': expected_message,
846 |                         'MessageAttributes': {
847 |                             'Test': {
848 |                                 'Type': 'String',
849 |                                 'Value': 'TestString'
850 |                             },
851 |                             'TestBinary': {
852 |                                 'Type': 'Binary',
853 |                                 'Value': 'TestBinary'
854 |                             }
855 |                         },
856 |                         'Type': 'Notification',
857 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
858 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
859 |                         'Subject': expected_subject
860 |                     }
861 |                 }
862 |             ]
863 |         }
864 | 
865 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message)
866 |         mock_get_webhook.return_value = expected_webhook
867 |         mock_format_stdf.return_value = expected_slack_message
868 |         mock_format_fallback.return_value = expected_slack_message_fallback
869 | 
870 |         # Act
871 |         lambda_function.lambda_handler(expected_event, expected_context)
872 | 
873 |         # Assert
874 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
875 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
876 |         mock_get_webhook.assert_called_once()
877 |         mock_format_fallback.assert_called_once_with(expected_message, fallback_reason=expected_subject)
878 |         mock_post_to_slack.assert_called_once_with(expected_webhook, expected_slack_message_fallback)
879 |         mock_format_stdf.assert_not_called()
880 | 
881 |     @unittest.mock.patch('lambda_slack.lambda_function.error_if_not_exactly_one_record')
882 |     @unittest.mock.patch('lambda_slack.lambda_function.get_subject_and_message')
883 |     @unittest.mock.patch('lambda_slack.lambda_function.get_webhook')
884 |     @unittest.mock.patch('lambda_slack.lambda_function.format_stdf')
885 |     @unittest.mock.patch('lambda_slack.lambda_function.format_fallback')
886 |     @unittest.mock.patch('lambda_slack.lambda_function.post_to_slack')
887 |     def test_handle_incoming_postfailed(self, mock_post_to_slack, mock_format_fallback, mock_format_stdf,
888 |                                         mock_get_webhook, mock_get_subject_and_message,
889 |                                         mock_error_if_not_exactly_one_record):
890 |         # Arrange
891 |         expected_message = '{"a": "b"}'
892 |         expected_subject = 'stdfMessage'
893 |         expected_slack_message = 'slackmessage'
894 |         expected_slack_message_fallback = 'fallbackmessage'
895 |         expected_error = '403'
896 |         expected_webhook = {
897 |             'host': 'http://a.a',
898 |             'path': '/a/b/c'
899 |         }
900 | 
901 |         expected_context = {}
902 | 
903 |         expected_event = {
904 |             'Records': [
905 |                 {
906 |                     'EventVersion': '1.0',
907 |                     'EventSubscriptionArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
908 |                     'EventSource': 'aws:sns',
909 |                     'Sns': {
910 |                         'SignatureVersion': '1',
911 |                         'Timestamp': '2019-01-02T12:45:07.000Z',
912 |                         'Signature': 'tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==',
913 |                         'SigningCertUrl': 'https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem',
914 |                         'MessageId': '95df01b4-ee98-5cb9-9903-4c221d41eb5e',
915 |                         'Message': expected_message,
916 |                         'MessageAttributes': {
917 |                             'Test': {
918 |                                 'Type': 'String',
919 |                                 'Value': 'TestString'
920 |                             },
921 |                             'TestBinary': {
922 |                                 'Type': 'Binary',
923 |                                 'Value': 'TestBinary'
924 |                             }
925 |                         },
926 |                         'Type': 'Notification',
927 |                         'UnsubscribeUrl': 'https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486',
928 |                         'TopicArn': 'arn:aws:sns:us-east-2:123456789012:sns-lambda',
929 |                         'Subject': expected_subject
930 |                     }
931 |                 }
932 |             ]
933 |         }
934 | 
935 |         expected_post_to_slack_calls = [
936 |             unittest.mock.call(expected_webhook, expected_slack_message),
937 |             unittest.mock.call(expected_webhook, expected_slack_message_fallback)
938 |         ]
939 | 
940 |         expected_post_to_slack_side_effect = [
941 |             ValueError(expected_error),
942 |             None
943 |         ]
944 | 
945 |         mock_post_to_slack.side_effect = expected_post_to_slack_side_effect
946 |         mock_get_subject_and_message.return_value = (expected_subject, expected_message)
947 |         mock_get_webhook.return_value = expected_webhook
948 |         mock_format_stdf.return_value = expected_slack_message
949 |         mock_format_fallback.return_value = expected_slack_message_fallback
950 | 
951 |         # Act
952 |         lambda_function.lambda_handler(expected_event, expected_context)
953 | 
954 |         # Assert
955 |         mock_error_if_not_exactly_one_record.assert_called_once_with(expected_event)
956 |         mock_get_subject_and_message.assert_called_once_with(expected_event)
957 |         mock_get_webhook.assert_called_once()
958 |         mock_format_stdf.assert_called_once_with(expected_message)
959 |         mock_format_fallback.assert_called_once_with(expected_message, fallback_reason=expected_error)
960 |         mock_post_to_slack.assert_has_calls(expected_post_to_slack_calls)
961 | 


--------------------------------------------------------------------------------