Add events target integration for sqs fifo queue (#3830)

* Add events target integration for sqs fifo queue

* Rename test file

tests/test_events/test_events.py

@@ -401,6 +401,35 @@ def test_put_targets_error_unknown_rule():
     )
 
 
+@mock_events
+def test_put_targets_error_missing_parameter_sqs_fifo():
+    # given
+    client = boto3.client("events", "eu-central-1")
+
+    # when
+    with pytest.raises(ClientError) as e:
+        client.put_targets(
+            Rule="unknown",
+            Targets=[
+                {
+                    "Id": "sqs-fifo",
+                    "Arn": "arn:aws:sqs:eu-central-1:{}:test-queue.fifo".format(
+                        ACCOUNT_ID
+                    ),
+                }
+            ],
+        )
+
+    # then
+    ex = e.value
+    ex.operation_name.should.equal("PutTargets")
+    ex.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
+    ex.response["Error"]["Code"].should.contain("ValidationException")
+    ex.response["Error"]["Message"].should.equal(
+        "Parameter(s) SqsParameters must be specified for target: sqs-fifo."
+    )
+
+
 @mock_events
 def test_permissions():
     client = boto3.client("events", "eu-central-1")

tests/test_events/test_events_integration.py

@@ -68,6 +68,94 @@ def test_send_to_cw_log_group():
     message["detail"].should.equal({"key": "value"})
 
 
+@mock_events
+@mock_sqs
+def test_send_to_sqs_fifo_queue():
+    # given
+    client_events = boto3.client("events", "eu-central-1")
+    client_sqs = boto3.client("sqs", region_name="eu-central-1")
+    rule_name = "test-rule"
+
+    queue_url = client_sqs.create_queue(
+        QueueName="test-queue.fifo", Attributes={"FifoQueue": "true"}
+    )["QueueUrl"]
+    queue_arn = client_sqs.get_queue_attributes(
+        QueueUrl=queue_url, AttributeNames=["QueueArn"]
+    )["Attributes"]["QueueArn"]
+    queue_url_dedup = client_sqs.create_queue(
+        QueueName="test-queue-dedup.fifo",
+        Attributes={"FifoQueue": "true", "ContentBasedDeduplication": "true"},
+    )["QueueUrl"]
+    queue_arn_dedup = client_sqs.get_queue_attributes(
+        QueueUrl=queue_url_dedup, AttributeNames=["QueueArn"]
+    )["Attributes"]["QueueArn"]
+
+    client_events.put_rule(
+        Name=rule_name,
+        EventPattern=json.dumps({"account": [ACCOUNT_ID]}),
+        State="ENABLED",
+    )
+    client_events.put_targets(
+        Rule=rule_name,
+        Targets=[
+            {
+                "Id": "sqs-fifo",
+                "Arn": queue_arn,
+                "SqsParameters": {"MessageGroupId": "group-id"},
+            },
+            {
+                "Id": "sqs-dedup-fifo",
+                "Arn": queue_arn_dedup,
+                "SqsParameters": {"MessageGroupId": "group-id"},
+            },
+        ],
+    )
+
+    # when
+    event_time = datetime(2021, 1, 1, 12, 23, 34)
+    client_events.put_events(
+        Entries=[
+            {
+                "Time": event_time,
+                "Source": "source",
+                "DetailType": "type",
+                "Detail": json.dumps({"key": "value"}),
+            }
+        ],
+    )
+
+    # then
+    response = client_sqs.receive_message(
+        QueueUrl=queue_url_dedup,
+        AttributeNames=["MessageDeduplicationId", "MessageGroupId"],
+    )
+    response["Messages"].should.have.length_of(1)
+    message = response["Messages"][0]
+    message["MessageId"].should_not.be.empty
+    message["ReceiptHandle"].should_not.be.empty
+    message["MD5OfBody"].should_not.be.empty
+
+    message["Attributes"]["MessageDeduplicationId"].should_not.be.empty
+    message["Attributes"]["MessageGroupId"].should.equal("group-id")
+
+    body = json.loads(message["Body"])
+    body["version"].should.equal("0")
+    body["id"].should_not.be.empty
+    body["detail-type"].should.equal("type")
+    body["source"].should.equal("source")
+    body["time"].should.equal(iso_8601_datetime_without_milliseconds(event_time))
+    body["region"].should.equal("eu-central-1")
+    body["resources"].should.be.empty
+    body["detail"].should.equal({"key": "value"})
+
+    # A FIFO queue without content-based deduplication enabled
+    # does not receive any event from the Event Bus
+    response = client_sqs.receive_message(
+        QueueUrl=queue_url, AttributeNames=["MessageDeduplicationId", "MessageGroupId"]
+    )
+    response.should_not.have.key("Messages")
+
+
 @mock_events
 @mock_sqs
 def test_send_to_sqs_queue():