cfn-bridge 0.0.1

data/spec/files/outputs-formation.json

@@ -0,0 +1,48 @@
+{
+    "AWSTemplateFormatVersion": "2010-09-09",
+
+    "Description": "Tests the CFN outputs resource",
+
+    "Parameters": {
+        "EntryTopic": {
+            "Description": "SNS topic that will be used",
+            "Type": "String"
+        },
+        "EntryQueue": {
+            "Description": "The queue to be polled",
+            "Type": "String"
+        },
+        "Name": {
+            "Description": "The CFN name to be loaded",
+            "Type": "String"
+        }
+    },
+
+    "Outputs": {
+        "Queue": {
+            "Description": "The queue to be polled",
+            "Value": {
+                "Fn::GetAtt": ["OutputsResource", "Queue"]
+            }
+        },
+        "Topic": {
+            "Description": "The topic to be polled",
+            "Value": {
+                "Fn::GetAtt": ["OutputsResource", "Topic"]
+            }
+        }
+    },
+
+    "Resources": {
+        "OutputsResource": {
+            "Type": "Custom::CloudFormationOutputs",
+            "Properties": {
+                "ServiceToken" : {"Ref" : "EntryTopic"},
+                "Name": {
+                    "Ref": "Name"
+                }
+            }
+        }
+    }
+
+}

data/spec/files/sample-create-message.json

@@ -0,0 +1,12 @@
+{
+  "Type" : "Notification",
+  "MessageId" : "2c954555-19cd-58b9-9461-0909bad60c89",
+  "TopicArn" : "arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z",
+  "Subject" : "AWS CloudFormation custom resource request",
+  "Message" : "{\"RequestType\":\"Create\",\"TopicArn\":\"arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z\",\"ResponseURL\":\"https://cloudformation-custom-resource-response-useast1.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-east-1%3A047170177871%3Astack/test-custom-11fa3098-9e58-4fb4-8af3-63e29a8fa4aa/4d120bd0-1db2-11e4-a357-500162a66ca8%7COutputsResource%7C51e2334b-ace8-4b52-bf7d-3c9f88610c20?AWSAccessKeyId=AKIAJNXHFR7P7YGKLDPQ&Expires=1407368443&Signature=LW%2BCCq8ypCC4qWVy2wdOFx6CTyA%3D\",\"StackId\":\"arn:aws:cloudformation:us-east-1:047170177871:stack/test-custom-11fa3098-9e58-4fb4-8af3-63e29a8fa4aa/4d120bd0-1db2-11e4-a357-500162a66ca8\",\"RequestId\":\"51e2334b-ace8-4b52-bf7d-3c9f88610c20\",\"LogicalResourceId\":\"OutputsResource\",\"ResourceType\":\"Custom::CloudFormationOutputs\",\"ResourceProperties\":{\"Name\":\"test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11\",\"ServiceToken\":\"arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z\"}}",
+  "Timestamp" : "2014-08-06T21:40:43.535Z",
+  "SignatureVersion" : "1",
+  "Signature" : "KSCvlwOejMvy61BVOfmbHqF3LCab0wpnuwlWLXUPXNl8tBjd8j1lHaFdtLzIB7B0jj+t6uvDHA/AM03TmNYuM9wXUO2A71oqls2PWIdchjoW/dCrjvdE0ztqmMLaMG87VqvrZVnIDYKQpZugl5a4AshKEPx2WcEUiLxMi9gjE5L0GpmEG7qE9xyJH7KMQemCAUcNOWAK1Y6LWRGybVICslEACn8NYJc92akDN6im7b9w+i71DJC7dFDEgC/3y7YeGCFsq9I/MQXv71JrWMaJxHfp+LOXP6ucISKBMfJYpBpB4GsVuB0jW/cELkPqFyb2WVvHxWiWm1wvh2K/Vuo74Q==",
+  "SigningCertURL" : "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-e372f8ca30337fdb084e8ac449342c77.pem",
+  "UnsubscribeURL" : "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z:1d19910d-8377-4c9d-a380-46102f10e36f"
+}

data/spec/files/sample-delete-message.json

@@ -0,0 +1,12 @@
+{
+  "Type" : "Notification",
+  "MessageId" : "f13ac688-5253-5d90-b825-8ad4f1631b9f",
+  "TopicArn" : "arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z",
+  "Subject" : "AWS CloudFormation custom resource request",
+  "Message" : "{\"RequestType\":\"Delete\",\"TopicArn\":\"arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z\",\"ResponseURL\":\"https://cloudformation-custom-resource-response-useast1.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-east-1%3A047170177871%3Astack/test-custom-11fa3098-9e58-4fb4-8af3-63e29a8fa4aa/4d120bd0-1db2-11e4-a357-500162a66ca8%7COutputsResource%7Cf3686111-7338-46be-b312-dd1baaea84b9?AWSAccessKeyId=AKIAJNXHFR7P7YGKLDPQ&Expires=1407368464&Signature=YXOhftA3sOP4YR6NV2c78wHkhP4%3D\",\"StackId\":\"arn:aws:cloudformation:us-east-1:047170177871:stack/test-custom-11fa3098-9e58-4fb4-8af3-63e29a8fa4aa/4d120bd0-1db2-11e4-a357-500162a66ca8\",\"RequestId\":\"f3686111-7338-46be-b312-dd1baaea84b9\",\"LogicalResourceId\":\"OutputsResource\",\"PhysicalResourceId\":\"arn:aws:cloudformation:us-east-1:047170177871:stack/test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11/39d01580-1db2-11e4-9b37-50fa5262a838\",\"ResourceType\":\"Custom::CloudFormationOutputs\",\"ResourceProperties\":{\"Name\":\"test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11\",\"ServiceToken\":\"arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z\"}}",
+  "Timestamp" : "2014-08-06T21:41:04.888Z",
+  "SignatureVersion" : "1",
+  "Signature" : "AkfEKcPydGagg5VJoSjWv1MkgwlCAaKuxHZ8NR6SOZePdcT/6H8OiE7epEjt9C17wtIx/WnqOHS7Nmm5PufogNYsxb2fCcZ9D6Av02vd1M5KwmpsRvWWHR2qLvOQk0lRjkkrD0Ol2Yt9TBwxsmYX77b6Nzg7Fn0qGoPNNwlCyUU0qfIQgXfDZR8SO9AZIS7GJ2MUTzXVJCNc5VoNcEDl+0y0yOrz97TetS4qBXhUaNhgfag/Zt/hMNHR+DKlirTSYWx7HhiSDt2jrlhsLMZy0wzMzKwV0Gp40xVZGc33kk38tt1ChrkKUzpEca3u8pRZ8f2jU0EI0Xh48Sn2tAGrLw==",
+  "SigningCertURL" : "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-e372f8ca30337fdb084e8ac449342c77.pem",
+  "UnsubscribeURL" : "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:047170177871:test-custom-b2bea71b-e1b8-4b8f-9855-1c92e1f0cd11-CustomResourcesTopic-1E5ZVSSFPY65Z:1d19910d-8377-4c9d-a380-46102f10e36f"
+}

data/spec/files/subscribe-to-sns-formation.json

@@ -0,0 +1,79 @@
+{
+    "AWSTemplateFormatVersion": "2010-09-09",
+
+    "Description": "Tests the subscribe sns to sqs resource",
+
+    "Parameters": {
+        "EntryTopic": {
+            "Description": "SNS topic that will be used",
+            "Type": "String"
+        }
+    },
+
+    "Outputs": {
+        "FirstQueue": {
+            "Description": "The first queue",
+            "Value": {
+                "Fn::GetAtt": ["FirstQueue", "QueueName"]
+            }
+        },
+        "FirstQueueArn": {
+            "Description": "The first queue",
+            "Value": {
+                "Fn::GetAtt": ["FirstQueue", "Arn"]
+            }
+        },
+        "FirstTopic": {
+            "Description": "The first topic",
+            "Value": {
+                "Ref": "FirstTopic"
+            }
+        },
+        "SubscriptionArn": {
+            "Description": "The arn for the subscription created",
+            "Value": {
+                "Fn::GetAtt": ["SubscribeResource", "Arn"]
+            }
+        },
+        "SubscriptionEndpoint": {
+            "Description": "The endpoint for the subscription created",
+            "Value": {
+                "Fn::GetAtt": ["SubscribeResource", "Endpoint"]
+            }
+        },
+        "SubscriptionProtocol": {
+            "Description": "The protocol for the subscription created",
+            "Value": {
+                "Fn::GetAtt": ["SubscribeResource", "Protocol"]
+            }
+        }
+    },
+
+    "Resources": {
+        "FirstQueue": {
+            "Type": "AWS::SQS::Queue",
+            "Properties": {
+                "ReceiveMessageWaitTimeSeconds": 20,
+                "VisibilityTimeout": 60
+            }
+        },
+        "FirstTopic": {
+            "Type": "AWS::SNS::Topic"
+        },
+        "SubscribeResource": {
+            "Type": "Custom::SubscribeSQSQueueToSNSTopic",
+            "Properties": {
+                "ServiceToken": {
+                    "Ref": "EntryTopic"
+                },
+                "TopicArn": {
+                    "Ref": "FirstTopic"
+                },
+                "QueueName": {
+                    "Fn::GetAtt": ["FirstQueue", "QueueName"]
+                }
+            }
+        }
+    }
+
+}

data/spec/files/test-formation.json

@@ -0,0 +1,75 @@
+{
+    "AWSTemplateFormatVersion": "2010-09-09",
+
+    "Description": "Creates the SNS topic, SQS queue and instance that will service the custom resources queue",
+
+    "Outputs": {
+        "Queue": {
+            "Description": "The queue to where we will poll messages",
+            "Value": {
+                "Fn::GetAtt": ["CustomResourcesQueue", "QueueName"]
+            }
+        },
+        "Topic" : {
+            "Description": "The topic that will be taking messages",
+            "Value": {
+                "Ref": "CustomResourcesTopic"
+            }
+        }
+    },
+
+    "Resources": {
+        "CustomResourcesQueue": {
+            "Type": "AWS::SQS::Queue",
+            "Properties": {
+                "ReceiveMessageWaitTimeSeconds": 20,
+                "VisibilityTimeout": 60
+            }
+        },
+        "CustomResourcesTopic": {
+            "Type": "AWS::SNS::Topic",
+            "Properties": {
+                "Subscription": [
+                    {
+                        "Endpoint": {
+                            "Fn::GetAtt": ["CustomResourcesQueue", "Arn"]
+                        },
+                        "Protocol": "sqs"
+                    }
+                ]
+            }
+        },
+        "SNSToSQSPolicy": {
+            "Type": "AWS::SQS::QueuePolicy",
+            "Properties": {
+                "PolicyDocument": {
+                    "Id": "PushMessageToSQSPolicy",
+                    "Version": "2012-10-17",
+                    "Statement": [
+                        {
+                            "Sid": "allow-sns-to-send-message-to-sqs",
+                            "Effect": "Allow",
+                            "Action": ["sqs:SendMessage"],
+                            "Principal": {
+                                "AWS": "*"
+                            },
+                            "Resource": "*",
+                            "Condition": {
+                                "ArnEquals": {
+                                    "aws:SourceArn": {
+                                        "Ref": "CustomResourcesTopic"
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                },
+                "Queues": [
+                    {
+                        "Ref": "CustomResourcesQueue"
+                    }
+                ]
+            }
+        }
+    }
+}

data/spec/lib/cloud_formation/bridge/executor_spec.rb

@@ -0,0 +1,66 @@
+require 'cloud_formation/bridge/executor'
+require 'cloud_formation/bridge/request'
+require 'cloud_formation/bridge/names'
+
+describe CloudFormation::Bridge::Executor do
+
+  FIELDS = CloudFormation::Bridge::Names::FIELDS
+  TYPES = CloudFormation::Bridge::Names::TYPES
+
+  let(:custom_resource) { double("custom-resource") }
+  let(:url) { "http://example.com/request-id" }
+  let(:custom_resource_name) { "sample-custom-resource" }
+  let(:registry) { { custom_resource_name => custom_resource } }
+  let(:response) { { FIELDS::LOGICAL_RESOURCE_ID => "sample-resource" } }
+
+  context 'when processing resources that are available' do
+
+    TYPES::ALL.each do |type|
+      it "should #{type.downcase} the resource if it is a #{type} request" do
+        request = CloudFormation::Bridge::Request.new(
+          FIELDS::REQUEST_TYPE => type,
+          FIELDS::RESOURCE_TYPE => custom_resource_name,
+        )
+
+        expect(custom_resource).to receive(type.downcase).with(request).and_return(response)
+
+        expect(request).to receive(:succeed!).with(response)
+
+        executor = CloudFormation::Bridge::Executor.new(registry)
+        executor.execute(request)
+      end
+    end
+
+    it 'should fail the request if the resource type is unknown' do
+      request = CloudFormation::Bridge::Request.new(
+        FIELDS::REQUEST_TYPE => TYPES::CREATE,
+        FIELDS::RESOURCE_TYPE => custom_resource_name,
+      )
+
+      expect(request).to receive(:fail!) do |message|
+        expect(message).to match(/#{custom_resource_name}/)
+      end
+
+      executor = CloudFormation::Bridge::Executor.new
+      executor.execute(request)
+    end
+
+    it 'should fail the request if the resource raised an exception' do
+      request = CloudFormation::Bridge::Request.new(
+        FIELDS::REQUEST_TYPE => TYPES::CREATE,
+        FIELDS::RESOURCE_TYPE => custom_resource_name,
+      )
+
+      message = "This should not have been called"
+      expect(custom_resource).to receive(:create).and_raise(ArgumentError.new(message))
+
+      expect(request).to receive(:fail!).with(message)
+
+      executor = CloudFormation::Bridge::Executor.new(registry)
+      executor.execute(request)
+    end
+
+  end
+
+
+end

data/spec/lib/cloud_formation/bridge/poller_spec.rb

@@ -0,0 +1,88 @@
+require 'cloud_formation/bridge/poller'
+require 'cloud_formation/bridge/executor'
+
+describe CloudFormation::Bridge::Poller do
+
+  include CloudFormationCreator
+  include FileSupport
+
+  shared_context 'pulls messages from queue' do
+
+    it "should correctly poll the queue and execute the message" do
+      message = read_file("sample-create-message.json")
+      queue.send_message(message)
+
+      expect(executor).to receive(:execute) do |request|
+        expect(request).to be_create
+        expect(request.logical_resource_id).to eq('OutputsResource')
+        expect(request.resource_type).to eq('Custom::CloudFormationOutputs')
+      end
+
+      expect(poller.visible_messages).to eq(1)
+
+      thread_poller = poller
+
+      thread = Thread.new do
+        thread_poller.start
+      end
+
+      while poller.visible_messages != 0
+        sleep(1)
+      end
+
+      poller.stop
+
+      thread.join
+    end
+
+  end
+
+  context 'in integration', integration: true do
+
+    let(:queue_name) { "test-cfn-queue-#{SecureRandom.uuid}" }
+    let(:queue) { queues.create(queue_name) }
+    let(:executor) { instance_double(CloudFormation::Bridge::Executor) }
+    let(:poller) { CloudFormation::Bridge::Poller.new(queue_name, executor) }
+
+    after do
+      queue.delete
+    end
+
+    include_context 'pulls messages from queue'
+
+  end
+
+  context 'in isolation' do
+
+    let(:queue_name) { "test-cfn-queue-#{SecureRandom.uuid}" }
+    let(:executor) { instance_double(CloudFormation::Bridge::Executor) }
+    let(:queue_items) { [] }
+    let(:queue) { instance_double(AWS::SQS::Queue) }
+    let(:poller) { CloudFormation::Bridge::Poller.new(queue_name, executor) }
+
+    before do
+      allow(queue).to receive(:send_message) do |message|
+        queue_items << message
+        nil
+      end
+      allow(queue).to receive(:visible_messages) { queue_items.size }
+      allow(queue).to receive(:receive_message) do
+        if queue_items.empty?
+          sleep(20)
+          nil
+        else
+          message = queue_items.shift
+          message_double = instance_double(AWS::SQS::ReceivedMessage, id: "some-id", body: message, handle: 'some-handle')
+          expect(message_double).to receive(:delete)
+          message_double
+        end
+      end
+
+      allow(poller).to receive(:queue).and_return(queue)
+    end
+
+    include_context 'pulls messages from queue'
+
+  end
+
+end

data/spec/lib/cloud_formation/bridge/request_spec.rb

@@ -0,0 +1,130 @@
+require 'cloud_formation/bridge/names'
+require 'cloud_formation/bridge/request'
+require 'cloud_formation/bridge/http_bridge'
+
+describe CloudFormation::Bridge::Request do
+
+  FIELDS = CloudFormation::Bridge::Names::FIELDS
+  TYPES = CloudFormation::Bridge::Names::TYPES
+  RESULTS = CloudFormation::Bridge::Names::RESULTS
+
+  let(:properties) do
+    {
+      "seleniumTester" => "SeleniumTest()",
+      "endpoints" => ["http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com"],
+      "frequencyOfTestsPerHour" => ["3", "2", "4"]
+    }
+  end
+
+  let(:request_hash) do
+    {
+      "RequestType" => "Create",
+      "ResponseURL" => "http://pre-signed-S3-url-for-response",
+      "StackId" => "arn:aws:cloudformation:us-east-1:EXAMPLE/stack-name/guid",
+      "RequestId" => "unique id for this create request",
+      "ResourceType" => "Custom::SeleniumTester",
+      "LogicalResourceId" => "MySeleniumTester",
+      "ResourceProperties" => properties,
+    }
+  end
+
+  let(:request) { CloudFormation::Bridge::Request.new(request_hash) }
+  let(:physical_id) { "sample-physical-id" }
+
+  context 'matching fields' do
+
+    it 'should correctly fill the values' do
+      expect(request).to be_create
+      expect(request.request_url).to eq("http://pre-signed-S3-url-for-response")
+      expect(request.stack_id).to eq("arn:aws:cloudformation:us-east-1:EXAMPLE/stack-name/guid")
+      expect(request.request_id).to eq("unique id for this create request")
+      expect(request.logical_resource_id).to eq("MySeleniumTester")
+      expect(request.resource_type).to eq("Custom::SeleniumTester")
+      expect(request.resource_properties).to eq(properties)
+    end
+
+    it 'should correctly detect an update request' do
+      request_hash["RequestType"] = 'Update'
+
+      expect(request).to be_update
+    end
+
+    it 'should correctly detect a delete request' do
+      request_hash["RequestType"] = 'Delete'
+
+      expect(request).to be_delete
+    end
+
+  end
+
+  context 'when building responses' do
+
+    it 'should correctly fill in the expected fields' do
+      response = request.build_response
+
+      expect(response).to include(
+        FIELDS::STATUS => RESULTS::SUCCESS,
+        FIELDS::STACK_ID => request.stack_id,
+        FIELDS::REQUEST_ID => request.request_id,
+        FIELDS::LOGICAL_RESOURCE_ID => request.logical_resource_id,
+      )
+
+      expect(response[FIELDS::PHYSICAL_RESOURCE_ID]).not_to be_empty
+    end
+
+    it 'should use the base response physical id if it was provided' do
+      base = {
+        FIELDS::PHYSICAL_RESOURCE_ID => physical_id,
+      }
+
+      response = request.build_response(base)
+
+      expect(response[FIELDS::PHYSICAL_RESOURCE_ID]).to eq(physical_id)
+    end
+
+    it 'should use the request physical id if the base response was not provided but request has it' do
+      request_hash[FIELDS::PHYSICAL_RESOURCE_ID] = physical_id
+      response = request.build_response
+      expect(response[FIELDS::PHYSICAL_RESOURCE_ID]).to eq(physical_id)
+    end
+
+  end
+
+  context 'when succeeding' do
+
+    it "should push the response with its own values" do
+      base = {
+        FIELDS::PHYSICAL_RESOURCE_ID => physical_id,
+      }
+
+      expect(CloudFormation::Bridge::HttpBridge).to receive(:put).with(request.request_url, request.build_response(base))
+
+      request.succeed!(base)
+    end
+
+  end
+
+  context 'when failing' do
+
+    it "should push the failure message with the known values" do
+      message = "failed to create resource"
+
+      expect(CloudFormation::Bridge::HttpBridge).to receive(:put) do |url, options|
+        expect(url).to eq(request.request_url)
+
+        response = request.build_response(
+          FIELDS::REASON => message,
+          FIELDS::STATUS => RESULTS::FAILED
+        )
+
+        response.delete(FIELDS::PHYSICAL_RESOURCE_ID)
+
+        expect(options).to include(response)
+      end
+
+      request.fail!(message)
+    end
+
+  end
+
+end

data/spec/lib/cloud_formation/bridge/resources/cloud_formation_outputs_spec.rb

@@ -0,0 +1,36 @@
+require 'cloud_formation/bridge/resources/cloud_formation_outputs'
+require 'cloud_formation/bridge/poller'
+
+describe CloudFormation::Bridge::Resources::CloudFormationOutputs do
+
+  include CloudFormationCreator
+
+  it 'should correctly pull the outputs from the CFN', integration: true do
+
+    with_main_formation do |stack, poller, outputs|
+      params = {
+        "Name" => stack.name,
+        "EntryTopic" => outputs["Topic"],
+        "EntryQueue" => outputs["Queue"],
+      }
+
+      with_cloud_formation('outputs-formation', params, false) do |outputs_stack|
+
+        wait_until "messages available" do
+          poller.visible_messages > 0
+        end
+
+        poller.poll
+
+        wait_until_complete(outputs_stack)
+
+        expected_outputs = stack_outputs(outputs_stack)
+
+        expect(outputs["Topic"]).to eq(expected_outputs["Topic"])
+        expect(outputs["Queue"]).to eq(expected_outputs["Queue"])
+      end
+    end
+
+  end
+
+end

data/spec/lib/cloud_formation/bridge/resources/subscribe_queue_to_topic_spec.rb

@@ -0,0 +1,95 @@
+require 'cloud_formation/bridge/resources/subscribe_queue_to_topic'
+require 'cloud_formation/bridge/names'
+require 'cloud_formation/bridge/poller'
+require 'cloud_formation/bridge/request'
+
+describe CloudFormation::Bridge::Resources::SubscribeQueueToTopic do
+
+  include CloudFormationCreator
+
+  context 'in isolation', integration: true do
+
+    let(:uuid) { SecureRandom.uuid }
+    let(:topic) { topics.create("cfn-test-topic-#{uuid}") }
+    let(:queue_name) { "cfn-test-queue-#{uuid}" }
+    let(:queue) { queues.create(queue_name) }
+
+    before do
+      @items = [topic, queue]
+    end
+
+    after do
+      @items.map(&:delete)
+    end
+
+    it 'should subscribe the the queue to the topic' do
+      request = CloudFormation::Bridge::Request.new(
+        CloudFormation::Bridge::Names::FIELDS::RESOURCE_PROPERTIES => {
+          CloudFormation::Bridge::Resources::SubscribeQueueToTopic::QUEUE_NAME => queue_name,
+          CloudFormation::Bridge::Resources::SubscribeQueueToTopic::TOPIC_ARN => topic.arn,
+        },
+      )
+
+      response = subject.create(request)
+      data = response[CloudFormation::Bridge::Names::FIELDS::DATA]
+
+      subscription = subscriptions[data[CloudFormation::Bridge::Resources::SubscribeQueueToTopic::ARN]]
+
+      payload = "this is the payload"
+
+      topic.publish( payload )
+
+      sleep(1)
+
+      message = queue.receive_message
+      body = JSON.parse(message.body)
+
+      expect(body["Message"]).to eq(payload)
+      expect(subscription.exists?).to eq(true)
+    end
+
+  end
+
+  context 'when creating the cloud formation' do
+
+    it "should accept a request and subscribe a queue to an SNS topic", integration: true do
+
+      with_main_formation do |_, poller, outputs|
+        params = {
+          "EntryTopic" => outputs["Topic"],
+        }
+
+        with_cloud_formation('subscribe-to-sns-formation', params, false) do |topics_stack|
+
+          wait_until "messages available" do
+            poller.visible_messages > 0
+          end
+
+          poller.poll
+
+          wait_until_complete(topics_stack)
+
+          message_body = "sample message"
+
+          topic = topics[topics_stack["FirstTopic"]]
+          topic.publish(message_body)
+
+          queue = queues.named(topics_stack["FirstQueue"])
+          message = queue.receive_message
+          message.delete
+
+          received_message = JSON.parse(message.body)["Message"]
+
+          expected_outputs = stack_outputs(topics_stack)
+
+          expect(received_message).to eq(message_body)
+          expect(expected_outputs["SubscriptionProtocol"]).to eq('sqs')
+          expect(expected_outputs["FirstQueueArn"]).to eq(expected_outputs["SubscriptionEndpoint"])
+        end
+      end
+
+    end
+
+  end
+
+end