Merge pull request #2833 from gmcrocetti/feat-events-cloudformation

Cloudformation support for Events::Rule

moto/cloudformation/parsing.py

@@ -18,6 +18,7 @@ from moto.ec2 import models as ec2_models
 from moto.ecs import models as ecs_models
 from moto.elb import models as elb_models
 from moto.elbv2 import models as elbv2_models
+from moto.events import models as events_models
 from moto.iam import models as iam_models
 from moto.kinesis import models as kinesis_models
 from moto.kms import models as kms_models
@@ -94,6 +95,7 @@ MODEL_MAP = {
     "AWS::SNS::Topic": sns_models.Topic,
     "AWS::S3::Bucket": s3_models.FakeBucket,
     "AWS::SQS::Queue": sqs_models.Queue,
+    "AWS::Events::Rule": events_models.Rule,
 }
 
 # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html

moto/events/models.py

@@ -26,12 +26,6 @@ class Rule(BaseModel):
         self.role_arn = kwargs.get("RoleArn")
         self.targets = []
 
-    def enable(self):
-        self.state = "ENABLED"
-
-    def disable(self):
-        self.state = "DISABLED"
-
     # This song and dance for targets is because we need order for Limits and NextTokens, but can't use OrderedDicts
     # with Python 2.6, so tracking it with an array it is.
     def _check_target_exists(self, target_id):
@@ -40,6 +34,16 @@ class Rule(BaseModel):
                 return i
         return None
 
+    def enable(self):
+        self.state = "ENABLED"
+
+    def disable(self):
+        self.state = "DISABLED"
+
+    def delete(self, region_name):
+        event_backend = events_backends[region_name]
+        event_backend.delete_rule(name=self.name)
+
     def put_targets(self, targets):
         # Not testing for valid ARNs.
         for target in targets:
@@ -55,6 +59,24 @@ class Rule(BaseModel):
             if index is not None:
                 self.targets.pop(index)
 
+    @classmethod
+    def create_from_cloudformation_json(
+        cls, resource_name, cloudformation_json, region_name
+    ):
+        properties = cloudformation_json["Properties"]
+        event_backend = events_backends[region_name]
+        event_name = properties.get("Name") or resource_name
+        return event_backend.put_rule(name=event_name, **properties)
+
+    @classmethod
+    def delete_from_cloudformation_json(
+        cls, resource_name, cloudformation_json, region_name
+    ):
+        properties = cloudformation_json["Properties"]
+        event_backend = events_backends[region_name]
+        event_name = properties.get("Name") or resource_name
+        event_backend.delete_rule(name=event_name)
+
 
 class EventBus(BaseModel):
     def __init__(self, region_name, name):
@@ -232,10 +254,10 @@ class EventsBackend(BaseBackend):
         return return_obj
 
     def put_rule(self, name, **kwargs):
-        rule = Rule(name, self.region_name, **kwargs)
+        new_rule = Rule(name, self.region_name, **kwargs)
-        self.rules[rule.name] = rule
+        self.rules[new_rule.name] = new_rule
-        self.rules_order.append(rule.name)
+        self.rules_order.append(new_rule.name)
-        return rule.arn
+        return new_rule
 
     def put_targets(self, name, targets):
         rule = self.rules.get(name)

moto/events/responses.py

@@ -191,7 +191,7 @@ class EventsHandler(BaseResponse):
                     "ValidationException", "Parameter ScheduleExpression is not valid."
                 )
 
-        rule_arn = self.events_backend.put_rule(
+        rule = self.events_backend.put_rule(
             name,
             ScheduleExpression=sched_exp,
             EventPattern=event_pattern,
@@ -200,7 +200,7 @@ class EventsHandler(BaseResponse):
             RoleArn=role_arn,
         )
 
-        return json.dumps({"RuleArn": rule_arn}), self.response_headers
+        return json.dumps({"RuleArn": rule.arn}), self.response_headers
 
     def put_targets(self):
         rule_name = self._get_param("Rule")

tests/test_cloudformation/test_cloudformation_stack_integration.py

@@ -29,6 +29,7 @@ from moto import (
     mock_ec2_deprecated,
     mock_elb,
     mock_elb_deprecated,
+    mock_events,
     mock_iam_deprecated,
     mock_kms,
     mock_lambda,
@@ -2379,3 +2380,85 @@ def test_create_log_group_using_fntransform():
     logs_conn = boto3.client("logs", region_name="us-west-2")
     log_group = logs_conn.describe_log_groups()["logGroups"][0]
     log_group["logGroupName"].should.equal("some-log-group")
+
+
+@mock_cloudformation
+@mock_events
+def test_stack_events_create_rule_integration():
+    events_template = {
+        "AWSTemplateFormatVersion": "2010-09-09",
+        "Resources": {
+            "Event": {
+                "Type": "AWS::Events::Rule",
+                "Properties": {
+                    "Name": "quick-fox",
+                    "State": "ENABLED",
+                    "ScheduleExpression": "rate(5 minutes)",
+                },
+            }
+        },
+    }
+    cf_conn = boto3.client("cloudformation", "us-west-2")
+    cf_conn.create_stack(
+        StackName="test_stack", TemplateBody=json.dumps(events_template),
+    )
+
+    rules = boto3.client("events", "us-west-2").list_rules()
+    rules["Rules"].should.have.length_of(1)
+    rules["Rules"][0]["Name"].should.equal("quick-fox")
+    rules["Rules"][0]["State"].should.equal("ENABLED")
+    rules["Rules"][0]["ScheduleExpression"].should.equal("rate(5 minutes)")
+
+
+@mock_cloudformation
+@mock_events
+def test_stack_events_delete_rule_integration():
+    events_template = {
+        "AWSTemplateFormatVersion": "2010-09-09",
+        "Resources": {
+            "Event": {
+                "Type": "AWS::Events::Rule",
+                "Properties": {
+                    "Name": "quick-fox",
+                    "State": "ENABLED",
+                    "ScheduleExpression": "rate(5 minutes)",
+                },
+            }
+        },
+    }
+    cf_conn = boto3.client("cloudformation", "us-west-2")
+    cf_conn.create_stack(
+        StackName="test_stack", TemplateBody=json.dumps(events_template),
+    )
+
+    rules = boto3.client("events", "us-west-2").list_rules()
+    rules["Rules"].should.have.length_of(1)
+
+    cf_conn.delete_stack(StackName="test_stack")
+
+    rules = boto3.client("events", "us-west-2").list_rules()
+    rules["Rules"].should.have.length_of(0)
+
+
+@mock_cloudformation
+@mock_events
+def test_stack_events_create_rule_without_name_integration():
+    events_template = {
+        "AWSTemplateFormatVersion": "2010-09-09",
+        "Resources": {
+            "Event": {
+                "Type": "AWS::Events::Rule",
+                "Properties": {
+                    "State": "ENABLED",
+                    "ScheduleExpression": "rate(5 minutes)",
+                },
+            }
+        },
+    }
+    cf_conn = boto3.client("cloudformation", "us-west-2")
+    cf_conn.create_stack(
+        StackName="test_stack", TemplateBody=json.dumps(events_template),
+    )
+
+    rules = boto3.client("events", "us-west-2").list_rules()
+    rules["Rules"][0]["Name"].should.contain("test_stack-Event-")

tests/test_events/test_events.py

@@ -1,15 +1,16 @@
-from moto.events.models import EventsBackend
-from moto.events import mock_events
 import json
 import random
 import unittest
 
 import boto3
+import sure  # noqa
 from botocore.exceptions import ClientError
-from moto.core.exceptions import JsonRESTError
 from nose.tools import assert_raises
 
 from moto.core import ACCOUNT_ID
+from moto.core.exceptions import JsonRESTError
+from moto.events import mock_events
+from moto.events.models import EventsBackend
 
 RULES = [
     {"Name": "test1", "ScheduleExpression": "rate(5 minutes)"},
@@ -75,6 +76,18 @@ def generate_environment():
     return client
 
 
+@mock_events
+def test_put_rule():
+    client = boto3.client("events", "us-west-2")
+
+    client.list_rules()["Rules"].should.have.length_of(0)
+
+    rule_data = get_random_rule()
+    client.put_rule(**rule_data)
+
+    client.list_rules()["Rules"].should.have.length_of(1)
+
+
 @mock_events
 def test_list_rules():
     client = generate_environment()