def test_create_sns_message_body(self):
action = {'Message': ['msg']}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
try:
uuid.UUID(result.pop('MessageId'))
except KeyError:
assert False, 'MessageId missing in SNS response message body'
except ValueError:
assert False, 'SNS response MessageId not a valid UUID'
try:
dateutil.parser.parse(result.pop('Timestamp'))
except KeyError:
assert False, 'Timestamp missing in SNS response message body'
except ValueError:
assert False, 'SNS response Timestamp not a valid ISO 8601 date'
self.assertEqual(result, {
'Message': 'msg',
'Type': 'Notification',
'TopicArn': 'arn'
})
# Now add a subject
action = {
'Message': ['msg'],
'Subject': ['subject'],
'MessageAttributes.entry.1.Name': ['attr1'],
'MessageAttributes.entry.1.Value.DataType': ['String'],
'MessageAttributes.entry.1.Value.StringValue': ['value1'],
'MessageAttributes.entry.1.Value.BinaryValue': ['value1'],
'MessageAttributes.entry.2.Name': ['attr2'],
'MessageAttributes.entry.2.Value.DataType': ['String'],
'MessageAttributes.entry.2.Value.StringValue': ['value2'],
'MessageAttributes.entry.2.Value.BinaryValue': ['value2'],
}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
del result['MessageId']
del result['Timestamp']
msg = {
'Message': 'msg',
'TopicArn': 'arn',
'Type': 'Notification',
'Subject': 'subject',
'MessageAttributes': {
'attr1': {
'Type': 'String',
'Value': 'value1',
},
'attr2': {
'Type': 'String',
'Value': 'value2',
}
}
}
expected = json.dumps(msg)
self.assertEqual(result, json.loads(expected))
def test_create_sns_message_body_json_structure_without_default_key(self):
action = {
'Message': ['{"message": "abc"}'],
'MessageStructure': ['json']
}
with assert_raises(Exception) as exc:
sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual(str(exc.exception), "Unable to find 'default' key in message payload")
def test_create_sns_message_body_json_structure_without_default_key(self):
action = {
'Message': ['{"message": "abc"}'],
'MessageStructure': ['json']
}
with assert_raises(Exception) as exc:
sns_listener.create_sns_message_body(self.subscriber, action)
assert str(exc.exception) == "Unable to find 'default' key in message payload"
def test_create_sns_message_body_json_structure_without_default_key(self):
action = {
"Message": ['{"message": "abc"}'],
"MessageStructure": ["json"]
}
with self.assertRaises(Exception) as exc:
sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual("Unable to find 'default' key in message payload",
str(exc.exception))
def test_create_sns_message_body():
subscriber = {
'TopicArn': 'arn',
'RawMessageDelivery': 'false',
}
action = {
'Message': ['msg']
}
result_str = sns_listener.create_sns_message_body(subscriber, action)
result = json.loads(result_str)
try:
uuid.UUID(result.pop('MessageId'))
except KeyError:
assert False, 'MessageId missing in SNS response message body'
except ValueError:
assert False, 'SNS response MessageId not a valid UUID'
assert_equal(result, {'Message': 'msg', 'Type': 'Notification', 'TopicArn': 'arn'})
# Now add a subject
action = {
'Message': ['msg'],
'Subject': ['subject'],
'MessageAttributes.entry.1.Name': ['attr1'],
'MessageAttributes.entry.1.Value.DataType': ['String'],
'MessageAttributes.entry.1.Value.StringValue': ['value1'],
'MessageAttributes.entry.1.Value.BinaryValue': ['value1'],
'MessageAttributes.entry.2.Name': ['attr2'],
'MessageAttributes.entry.2.Value.DataType': ['String'],
'MessageAttributes.entry.2.Value.StringValue': ['value2'],
'MessageAttributes.entry.2.Value.BinaryValue': ['value2'],
}
result_str = sns_listener.create_sns_message_body(subscriber, action)
result = json.loads(result_str)
del result['MessageId']
expected = json.dumps({'Message': 'msg',
'TopicArn': 'arn',
'Type': 'Notification',
'Subject': 'subject',
'MessageAttributes': {
'attr1': {
'Type': 'String',
'Value': 'value1',
}, 'attr2': {
'Type': 'String',
'Value': 'value2',
}
}})
assert_equal(result, json.loads(expected))
def test_create_sns_message_body_raw_message_delivery(self):
self.subscriber['RawMessageDelivery'] = 'true'
action = {
'Message': ['msg']
}
result = sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual(result, 'msg')
def test_create_sns_message_body_raw_message_delivery(self):
self.subscriber['RawMessageDelivery'] = 'true'
action = {
'Message': ['msg']
}
result = sns_listener.create_sns_message_body(self.subscriber, action)
assert (result == 'msg')
def test_create_sns_message_body_json_structure_raw_delivery(self):
self.subscriber["RawMessageDelivery"] = "true"
action = {
"Message": ['{"default": {"message": "abc"}}'],
"MessageStructure": ["json"],
}
result = sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual({"message": "abc"}, result)
def test_create_sns_message_body_json_structure(self):
action = {
'Message': ['{"default": {"message": "abc"}}'],
'MessageStructure': ['json']
}
result_str = sns_listener.create_sns_message_body(self.subscriber, action)
result = json.loads(result_str)
assert (result['Message'] == {'message': 'abc'})
def test_create_sns_message_body_json_structure_sqs_protocol(self):
action = {
'Message': ['{"default": "default message", "sqs": "sqs message"}'],
'MessageStructure': ['json']
}
result_str = sns_listener.create_sns_message_body(self.subscriber, action)
result = json.loads(result_str)
assert (result['Message'] == 'sqs message')
def test_create_sns_message_body_json_structure_raw_delivery(self):
self.subscriber['RawMessageDelivery'] = 'true'
action = {
'Message': ['{"default": {"message": "abc"}}'],
'MessageStructure': ['json']
}
result = sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual(result, {'message': 'abc'})
def test_create_sns_message_body_json_structure_sqs_protocol(self):
action = {
'Message': ['{"default": "default message", "sqs": "sqs message"}'],
'MessageStructure': ['json']
}
result_str = sns_listener.create_sns_message_body(self.subscriber, action)
result = json.loads(result_str)
self.assertEqual(result['Message'], 'sqs message')
def test_create_sns_message_body_raw_message_delivery():
subscriber = {
'RawMessageDelivery': 'true'
}
action = {
'Message': ['msg']
}
result = sns_listener.create_sns_message_body(subscriber, action)
assert (result == 'msg')
def test_create_sns_message_body_json_structure(self):
action = {
'Message': ['{"default": {"message": "abc"}}'],
'MessageStructure': ['json']
}
result_str = sns_listener.create_sns_message_body(self.subscriber, action)
result = json.loads(result_str)
self.assertEqual(result['Message'], {'message': 'abc'})
def test_create_sns_message_body(self):
action = {
'Message': ['msg']
}
result_str = sns_listener.create_sns_message_body(self.subscriber, action)
result = json.loads(result_str)
try:
uuid.UUID(result.pop('MessageId'))
except KeyError:
assert False, 'MessageId missing in SNS response message body'
except ValueError:
assert False, 'SNS response MessageId not a valid UUID'
assert_equal(result, {'Message': 'msg', 'Type': 'Notification', 'TopicArn': 'arn'})
# Now add a subject
action = {
'Message': ['msg'],
'Subject': ['subject'],
'MessageAttributes.entry.1.Name': ['attr1'],
'MessageAttributes.entry.1.Value.DataType': ['String'],
'MessageAttributes.entry.1.Value.StringValue': ['value1'],
'MessageAttributes.entry.1.Value.BinaryValue': ['value1'],
'MessageAttributes.entry.2.Name': ['attr2'],
'MessageAttributes.entry.2.Value.DataType': ['String'],
'MessageAttributes.entry.2.Value.StringValue': ['value2'],
'MessageAttributes.entry.2.Value.BinaryValue': ['value2'],
}
result_str = sns_listener.create_sns_message_body(self.subscriber, action)
result = json.loads(result_str)
del result['MessageId']
expected = json.dumps({'Message': 'msg',
'TopicArn': 'arn',
'Type': 'Notification',
'Subject': 'subject',
'MessageAttributes': {
'attr1': {
'Type': 'String',
'Value': 'value1',
}, 'attr2': {
'Type': 'String',
'Value': 'value2',
}
}})
assert_equal(result, json.loads(expected))
def test_create_sns_message_body():
subscriber = {
'TopicArn': 'arn',
'RawMessageDelivery': 'false',
}
action = {'Message': ['msg']}
result = sns_listener.create_sns_message_body(subscriber, action)
assert_equal(json.loads(result), {
'Message': 'msg',
'Type': 'Notification',
'TopicArn': 'arn'
})
# Now add a subject
action = {
'Message': ['msg'],
'Subject': ['subject'],
'MessageAttributes.entry.1.Name': ['attr1'],
'MessageAttributes.entry.1.Value.DataType': ['String'],
'MessageAttributes.entry.1.Value.StringValue': ['value1'],
'MessageAttributes.entry.1.Value.BinaryValue': ['value1'],
'MessageAttributes.entry.2.Name': ['attr2'],
'MessageAttributes.entry.2.Value.DataType': ['String'],
'MessageAttributes.entry.2.Value.StringValue': ['value2'],
'MessageAttributes.entry.2.Value.BinaryValue': ['value2'],
}
result = sns_listener.create_sns_message_body(subscriber, action)
expected = json.dumps({
'Message': 'msg',
'TopicArn': 'arn',
'Type': 'Notification',
'Subject': 'subject',
'MessageAttributes': {
'attr1': {
'Type': 'String',
'Value': 'value1',
},
'attr2': {
'Type': 'String',
'Value': 'value2',
}
}
})
assert_equal(json.loads(result), json.loads(expected))
def test_create_sns_message_body_json_structure(self):
action = {
"Message": ['{"default": {"message": "abc"}}'],
"MessageStructure": ["json"],
}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
self.assertEqual({"message": "abc"}, result["Message"])
def test_create_sns_message_timestamp_millis(self):
action = {'Message': ['msg']}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
timestamp = result.pop('Timestamp')
end = timestamp[-5:]
matcher = re.compile(r'\.[0-9]{3}Z')
match = matcher.match(end)
self.assertTrue(match is not None)
def test_create_sns_message_timestamp_millis(self):
action = {"Message": ["msg"]}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
timestamp = result.pop("Timestamp")
end = timestamp[-5:]
matcher = re.compile(r"\.[0-9]{3}Z")
match = matcher.match(end)
self.assertIsNotNone(match)
def test_create_sns_message_body_json_structure_sqs_protocol(self):
action = {
"Message":
['{"default": "default message", "sqs": "sqs message"}'],
"MessageStructure": ["json"],
}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
self.assertEqual("sqs message", result["Message"])
def test_create_sns_message_body_json_structure_raw_delivery_sqs_protocol(
self):
self.subscriber['RawMessageDelivery'] = 'true'
action = {
'Message': [
'{"default": {"message": "default version"}, "sqs": {"message": "sqs version"}}'
],
'MessageStructure': ['json']
}
result = sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual({'message': 'sqs version'}, result)
def test_create_sns_message_body_raw_message_delivery(self):
self.subscriber["RawMessageDelivery"] = "true"
action = {"Message": ["msg"]}
result = sns_listener.create_sns_message_body(self.subscriber, action)
self.assertEqual("msg", result)
def test_create_sns_message_body(self):
action = {"Message": ["msg"]}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action, str(uuid.uuid4()))
result = json.loads(result_str)
try:
uuid.UUID(result.pop("MessageId"))
except KeyError:
assert False, "MessageId missing in SNS response message body"
except ValueError:
assert False, "SNS response MessageId not a valid UUID"
try:
dateutil.parser.parse(result.pop("Timestamp"))
except KeyError:
assert False, "Timestamp missing in SNS response message body"
except ValueError:
assert False, "SNS response Timestamp not a valid ISO 8601 date"
expected_sns_body = {
"Message": "msg",
"Signature": "EXAMPLEpH+..",
"SignatureVersion": "1",
"SigningCertURL":
"https://sns.us-east-1.amazonaws.com/SimpleNotificationService-0000000000000000000000.pem",
"TopicArn": "arn",
"Type": "Notification",
}
self.assertEqual(expected_sns_body, result)
# Now add a subject
action = {
"Message": ["msg"],
"Subject": ["subject"],
"MessageAttributes.entry.1.Name": ["attr1"],
"MessageAttributes.entry.1.Value.DataType": ["String"],
"MessageAttributes.entry.1.Value.StringValue": ["value1"],
"MessageAttributes.entry.1.Value.BinaryValue": ["value1"],
"MessageAttributes.entry.2.Name": ["attr2"],
"MessageAttributes.entry.2.Value.DataType": ["String"],
"MessageAttributes.entry.2.Value.StringValue": ["value2"],
"MessageAttributes.entry.2.Value.BinaryValue": ["value2"],
}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
del result["MessageId"]
del result["Timestamp"]
msg = {
"Message": "msg",
"Subject": "subject",
"Signature": "EXAMPLEpH+..",
"SignatureVersion": "1",
"SigningCertURL":
"https://sns.us-east-1.amazonaws.com/SimpleNotificationService-0000000000000000000000.pem",
"TopicArn": "arn",
"Type": "Notification",
"MessageAttributes": {
"attr1": {
"Type": "String",
"Value": "value1",
},
"attr2": {
"Type": "String",
"Value": "value2",
},
},
}
self.assertEqual(msg, result)
def test_create_sns_message_body(self):
action = {'Message': ['msg']}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action, str(uuid.uuid4()))
result = json.loads(result_str)
try:
uuid.UUID(result.pop('MessageId'))
except KeyError:
assert False, 'MessageId missing in SNS response message body'
except ValueError:
assert False, 'SNS response MessageId not a valid UUID'
try:
dateutil.parser.parse(result.pop('Timestamp'))
except KeyError:
assert False, 'Timestamp missing in SNS response message body'
except ValueError:
assert False, 'SNS response Timestamp not a valid ISO 8601 date'
self.assertEqual(
result, {
'Message': 'msg',
'Signature': 'EXAMPLEpH+..',
'SignatureVersion': '1',
'SigningCertURL':
'https://sns.us-east-1.amazonaws.com/SimpleNotificationService-0000000000000000000000.pem',
'SubscribeURL': None,
'Token': None,
'TopicArn': 'arn',
'Type': 'Notification'
})
# Now add a subject
action = {
'Message': ['msg'],
'Subject': ['subject'],
'MessageAttributes.entry.1.Name': ['attr1'],
'MessageAttributes.entry.1.Value.DataType': ['String'],
'MessageAttributes.entry.1.Value.StringValue': ['value1'],
'MessageAttributes.entry.1.Value.BinaryValue': ['value1'],
'MessageAttributes.entry.2.Name': ['attr2'],
'MessageAttributes.entry.2.Value.DataType': ['String'],
'MessageAttributes.entry.2.Value.StringValue': ['value2'],
'MessageAttributes.entry.2.Value.BinaryValue': ['value2'],
}
result_str = sns_listener.create_sns_message_body(
self.subscriber, action)
result = json.loads(result_str)
del result['MessageId']
del result['Timestamp']
msg = {
'Message': 'msg',
'Subject': 'subject',
'Signature': 'EXAMPLEpH+..',
'SignatureVersion': '1',
'SigningCertURL':
'https://sns.us-east-1.amazonaws.com/SimpleNotificationService-0000000000000000000000.pem',
'SubscribeURL': None,
'Token': None,
'TopicArn': 'arn',
'Type': 'Notification',
'MessageAttributes': {
'attr1': {
'Type': 'String',
'Value': 'value1',
},
'attr2': {
'Type': 'String',
'Value': 'value2',
}
}
}
expected = json.dumps(msg)
self.assertEqual(result, json.loads(expected))
