cfn-bridge 0.0.9 → 0.0.10

data/spec/files/describe-cache-cluster-replica-done.json

@@ -0,0 +1,68 @@
+{
+  "cache_clusters": [
+    {
+      "cache_security_groups": [
+        {
+          "cache_security_group_name": "redis-group",
+          "status": "active"
+        }
+      ],
+      "cache_nodes": [
+        {
+          "parameter_group_status": "in-sync",
+          "cache_node_status": "available",
+          "cache_node_create_time": "2014-09-10 02:25:13 UTC",
+          "cache_node_id": "0001",
+          "customer_availability_zone": "us-east-1a",
+          "endpoint": {
+            "port": 6379,
+            "address": "dev-redis-replica.mzufvw.0001.use1.cache.amazonaws.com"
+          }
+        },
+        {
+          "parameter_group_status": "in-sync",
+          "cache_node_status": "available",
+          "cache_node_create_time": "2014-09-10 02:25:13 UTC",
+          "cache_node_id": "0001",
+          "customer_availability_zone": "us-east-1a",
+          "endpoint": {
+            "port": 6379,
+            "address": "dev-redis-replica.mzufvw.0002.use1.cache.amazonaws.com"
+          }
+        }
+      ],
+      "security_groups": [
+
+      ],
+      "cache_cluster_id": "dev-redis-replica",
+      "cache_parameter_group": {
+        "cache_node_ids_to_reboot": [
+
+        ],
+        "cache_parameter_group_name": "default.redis2.8",
+        "parameter_apply_status": "in-sync"
+      },
+      "cache_cluster_status": "available",
+      "replication_group_id": "dev-redis-rep-group",
+      "cache_node_type": "cache.m1.small",
+      "engine": "redis",
+      "pending_modified_values": {
+        "cache_node_ids_to_remove": [
+
+        ]
+      },
+      "preferred_availability_zone": "us-east-1a",
+      "cache_cluster_create_time": "2014-09-10 02:25:13 UTC",
+      "engine_version": "2.8.6",
+      "auto_minor_version_upgrade": true,
+      "preferred_maintenance_window": "thu:10:00-thu:11:00",
+      "client_download_landing_page": "https://console.aws.amazon.com/elasticache/home#client-download:",
+      "snapshot_retention_limit": 0,
+      "num_cache_nodes": 1,
+      "snapshot_window": "09:00-10:00"
+    }
+  ],
+  "response_metadata": {
+    "request_id": "3913b189-3892-11e4-8c6b-f3805709d592"
+  }
+}

data/spec/files/describe-cache-cluster-replica.json

@@ -0,0 +1,46 @@
+{
+  "cache_clusters": [
+    {
+      "cache_security_groups": [
+        {
+          "cache_security_group_name": "redis-group",
+          "status": "active"
+        }
+      ],
+      "cache_nodes": [
+
+      ],
+      "security_groups": [
+
+      ],
+      "cache_cluster_id": "dev-redis-replica",
+      "cache_parameter_group": {
+        "cache_node_ids_to_reboot": [
+
+        ],
+        "parameter_apply_status": "in-sync",
+        "cache_parameter_group_name": "default.redis2.8"
+      },
+      "cache_cluster_status": "creating",
+      "replication_group_id": "dev-redis-rep-group",
+      "cache_node_type": "cache.m1.small",
+      "engine": "redis",
+      "pending_modified_values": {
+        "cache_node_ids_to_remove": [
+
+        ]
+      },
+      "preferred_availability_zone": "us-east-1a",
+      "engine_version": "2.8.6",
+      "auto_minor_version_upgrade": true,
+      "preferred_maintenance_window": "thu:10:00-thu:11:00",
+      "client_download_landing_page": "https://console.aws.amazon.com/elasticache/home#client-download:",
+      "snapshot_retention_limit": 0,
+      "num_cache_nodes": 1,
+      "snapshot_window": "09:00-10:00"
+    }
+  ],
+  "response_metadata": {
+    "request_id": "3d98e0e9-3891-11e4-8fa2-cfebce712279"
+  }
+}

data/spec/files/describe-memcached-cluster.json

@@ -0,0 +1,73 @@
+{ "cache_clusters": [
+  {
+    "auto_minor_version_upgrade": true,
+    "cache_cluster_create_time": "2013-05-28 07:42:19 UTC",
+    "cache_cluster_id": "somecache",
+    "cache_cluster_status": "available",
+    "cache_node_type": "cache.t1.micro",
+    "cache_nodes": [
+      {
+        "cache_node_create_time": "2013-05-28 07:42:19 UTC",
+        "cache_node_id": "0001",
+        "cache_node_status": "available",
+        "customer_availability_zone": "us-east-1a",
+        "endpoint": {
+          "address": "somecache.tgbhomz.0001.use1.cache.amazonaws.com",
+          "port": 11211
+        },
+        "parameter_group_status": "in-sync"
+      },
+      {
+        "cache_node_create_time": "2013-05-28 07:42:19 UTC",
+        "cache_node_id": "0002",
+        "cache_node_status": "available",
+        "customer_availability_zone": "us-east-1a",
+        "endpoint": {
+          "address": "somecache.tgbhomz.0002.use1.cache.amazonaws.com",
+          "port": 11211
+        },
+        "parameter_group_status": "in-sync"
+      },
+      {
+        "cache_node_create_time": "2013-05-28 07:42:19 UTC",
+        "cache_node_id": "0003",
+        "cache_node_status": "available",
+        "customer_availability_zone": "us-east-1a",
+        "endpoint": {
+          "address": "somecache.tgbhomz.0003.use1.cache.amazonaws.com",
+          "port": 11211
+        },
+        "parameter_group_status": "in-sync"
+      }
+    ],
+    "cache_parameter_group": {
+      "cache_node_ids_to_reboot": [  ],
+      "cache_parameter_group_name": "default.memcached1.4",
+      "parameter_apply_status": "in-sync"
+    },
+    "cache_security_groups": [
+      {
+        "cache_security_group_name": "cache_security_group",
+        "status": "active"
+      }
+    ],
+    "client_download_landing_page": "https://console.aws.amazon.com/elasticache/home#client-download:",
+    "configuration_endpoint": {
+      "address": "somecache.tgbhomz.cfg.use1.cache.amazonaws.com",
+      "port": 11211
+    },
+    "engine": "memcached",
+    "engine_version": "1.4.14",
+    "num_cache_nodes": 3,
+    "pending_modified_values": {
+      "cache_node_ids_to_remove": [  ]
+    },
+    "preferred_availability_zone": "us-east-1a",
+    "preferred_maintenance_window": "sun:07:30-sun:08:30",
+    "security_groups": [  ]
+  }
+],
+  "response_metadata": {
+    "request_id": "585fd79c-3dd2-11e4-bf11-4b077bcebe02"
+  }
+}

data/spec/files/describe-replication-group-primary-and-replica.json

@@ -0,0 +1,49 @@
+{
+  "replication_groups": [
+    {
+      "member_clusters": [
+        "red-re-1uptio9f2ytdi",
+        "rn-redisclu-a7392cba"
+      ],
+      "node_groups": [
+        {
+          "node_group_members": [
+            {
+              "cache_cluster_id": "red-re-1uptio9f2ytdi",
+              "read_endpoint": {
+                "port": 6379,
+                "address": "red-re-1uptio9f2ytdi.mzufvw.0001.use1.cache.amazonaws.com"
+              },
+              "preferred_availability_zone": "us-east-1c",
+              "cache_node_id": "0001",
+              "current_role": "primary"
+            },
+            {
+              "cache_cluster_id": "rn-redisclu-a7392cba",
+              "read_endpoint": {
+                "port": 6379,
+                "address": "rn-redisclu-a7392cba.mzufvw.0001.use1.cache.amazonaws.com"
+              },
+              "preferred_availability_zone": "us-east-1a",
+              "cache_node_id": "0001",
+              "current_role": "replica"
+            }
+          ],
+          "primary_endpoint": {
+            "port": 6379,
+            "address": "rg-redisclu-2ffb4776.mzufvw.ng.0001.use1.cache.amazonaws.com"
+          },
+          "node_group_id": "0001",
+          "status": "available"
+        }
+      ],
+      "replication_group_id": "rg-redisclu-2ffb4776",
+      "status": "available",
+      "description": "Sample replication group for the redis instances",
+      "pending_modified_values": null
+    }
+  ],
+  "response_metadata": {
+    "request_id": "d9700c9d-3891-11e4-9cb8-252ab83f5b14"
+  }
+}

data/spec/files/describe-replication-group-primary-only.json

@@ -0,0 +1,38 @@
+{
+  "replication_groups": [
+    {
+      "member_clusters": [
+        "cluster-id-here"
+      ],
+      "node_groups": [
+        {
+          "node_group_members": [
+            {
+              "cache_cluster_id": "cluster-id-here",
+              "read_endpoint": {
+                "port": 6379,
+                "address": "cluster-id-here.mzufvw.0001.use1.cache.amazonaws.com"
+              },
+              "preferred_availability_zone": "us-east-1c",
+              "cache_node_id": "0001",
+              "current_role": "primary"
+            }
+          ],
+          "node_group_id": "0001",
+          "primary_endpoint": {
+            "port": 6379,
+            "address": "cluster-id-here.mzufvw.ng.0001.use1.cache.amazonaws.com"
+          },
+          "status": "available"
+        }
+      ],
+      "replication_group_id": "dev-redis-rep",
+      "status": "available",
+      "pending_modified_values": null,
+      "description": "Sample replication group for the redis instances"
+    }
+  ],
+  "response_metadata": {
+    "request_id": "a4a0eaab-3891-11e4-8cb6-9f87081a8ee3"
+  }
+}

data/spec/files/outputs-formation.json

@@ -8,10 +8,6 @@
             "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"

data/spec/files/sample-replica-cluster.json

@@ -0,0 +1,51 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "AWS CloudFormation template for standing a redis cluster.",
+
+  "Parameters": {
+    "EntryTopic": {
+      "Description": "SNS topic that will be used no notify custom resource creation",
+      "Type": "String"
+    }
+  },
+
+  "Resources": {
+    "RedisClusterReplicationGroup": {
+      "Type": "Custom::ElastiCacheReplicationGroup",
+      "Properties": {
+        "ServiceToken": {
+          "Ref": "EntryTopic"
+        },
+        "ClusterId": "cluster-id-here",
+        "ReplicationGroupId": "dev-redis-rep-group",
+        "Description": "Sample replication group for the redis instances"
+      }
+    },
+    "RedisReplicaCluster": {
+      "Type": "Custom::ElastiCacheReplicaCluster",
+      "Properties": {
+        "ServiceToken": {
+          "Ref": "EntryTopic"
+        },
+        "ReplicaClusterId": "dev-redis-replica",
+        "ReplicationGroupId": {
+          "Fn::GetAtt": ["RedisClusterReplicationGroup", "ReplicationGroupId"]
+        }
+      }
+    }
+  },
+
+  "Outputs": {
+    "ReplicationGroupId": {
+      "Value": {
+        "Fn::GetAtt": ["RedisClusterReplicationGroup", "ReplicationGroupId"]
+      }
+    },
+    "ReplicaClusterURLs": {
+      "Value": {
+        "Fn::GetAtt": [ "RedisReplicaCluster", "NodeURLs" ]
+      }
+    }
+  }
+
+}

data/spec/files/sample-replication-group.json

@@ -0,0 +1,34 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "AWS CloudFormation template for standing a redis cluster.",
+
+  "Parameters": {
+    "EntryTopic": {
+      "Description": "SNS topic that will be used no notify custom resource creation",
+      "Type": "String"
+    }
+  },
+
+  "Resources": {
+    "RedisClusterReplicationGroup": {
+      "Type": "Custom::ElastiCacheReplicationGroup",
+      "Properties": {
+        "ServiceToken": {
+          "Ref": "EntryTopic"
+        },
+        "ClusterId": "cluster-id-here",
+        "ReplicationGroupId" : "dev-redis-rep",
+        "Description": "Sample replication group for the redis instances"
+      }
+    }
+  },
+
+  "Outputs": {
+    "ReplicaURLs": {
+      "Value": {
+        "Fn::GetAtt": ["RedisClusterReplicationGroup", "ReplicationGroupId"]
+      }
+    }
+  }
+
+}

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

@@ -54,7 +54,7 @@ describe CloudFormation::Bridge::Executor do
       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)
+      expect(request).to receive(:fail!).with("ArgumentError - #{message}")
 
       executor = CloudFormation::Bridge::Executor.new(registry)
       executor.execute(request)

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

@@ -63,11 +63,11 @@ describe CloudFormation::Bridge::Request 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,
-      )
+                            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
@@ -102,6 +102,18 @@ describe CloudFormation::Bridge::Request do
       request.succeed!(base)
     end
 
+    it "ignores the provided response if it is not a hash" do
+      expect(CloudFormation::Bridge::HttpBridge).to receive(:put) do |url, options|
+        expect(url).to eq(request.request_url)
+
+        expected_response = request.build_response
+        expected_response.delete(FIELDS::PHYSICAL_RESOURCE_ID)
+
+        expect(options).to include(expected_response)
+      end
+      request.succeed!(true)
+    end
+
   end
 
   context 'when failing' do

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

@@ -0,0 +1,61 @@
+require 'cloud_formation/bridge/names'
+require 'cloud_formation/bridge/request'
+require 'cloud_formation/bridge/resources/elasti_cache_node_urls'
+
+describe CloudFormation::Bridge::Resources::ElastiCacheNodeUrls do
+
+  FIELDS = CloudFormation::Bridge::Names::FIELDS
+  ELASTI_CACHE = CloudFormation::Bridge::Names::ELASTI_CACHE
+
+  include FileSupport
+
+  context '#create' do
+
+    it 'produces the node URLs for a memcached cluster' do
+      cluster_id = "samplecache"
+
+      expect(subject.client).to receive(:describe_cache_clusters).
+                                  with(cache_cluster_id: cluster_id,
+                                       show_cache_node_info: true).twice.and_return(parse_json("describe-memcached-cluster"))
+
+      request = CloudFormation::Bridge::Request.new(parse_json("create-cache-node-urls-message", false))
+
+      outputs = subject.create(request)
+
+      expect(outputs).to eq(
+                           {
+                             FIELDS::DATA => {
+                               ELASTI_CACHE::REPLICA_CLUSTER_ID => cluster_id,
+                               ELASTI_CACHE::NODE_URLS => "somecache.tgbhomz.cfg.use1.cache.amazonaws.com:11211",
+                             },
+                             FIELDS::PHYSICAL_RESOURCE_ID => cluster_id,
+                           }
+                         )
+
+    end
+
+    it 'produces the node URLs for a redis cluster' do
+      cluster_id = "dev-redis-replica"
+      expect(subject.client).to receive(:describe_cache_clusters).
+                                  with(cache_cluster_id: cluster_id,
+                                       show_cache_node_info: true).twice.and_return(parse_json("describe-cache-cluster-replica-done"))
+
+      request = CloudFormation::Bridge::Request.new(parse_json("create-redis-cache-node-urls-message", false))
+
+      outputs = subject.create(request)
+
+      expect(outputs).to eq(
+                           {
+                             FIELDS::DATA => {
+                               ELASTI_CACHE::REPLICA_CLUSTER_ID => cluster_id,
+                               ELASTI_CACHE::NODE_URLS => "dev-redis-replica.mzufvw.0001.use1.cache.amazonaws.com:6379,dev-redis-replica.mzufvw.0002.use1.cache.amazonaws.com:6379",
+                             },
+                             FIELDS::PHYSICAL_RESOURCE_ID => cluster_id,
+                           }
+                         )
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,67 @@
+require 'cloud_formation/bridge/names'
+require 'cloud_formation/bridge/resources/elasti_cache_replica_cluster'
+
+describe CloudFormation::Bridge::Resources::ElastiCacheReplicaCluster do
+
+  FIELDS = CloudFormation::Bridge::Names::FIELDS
+  ELASTI_CACHE = CloudFormation::Bridge::Names::ELASTI_CACHE
+
+  include FileSupport
+
+  let(:creating) { parse_json("describe-cache-cluster-replica") }
+  let(:available) { parse_json("describe-cache-cluster-replica-done") }
+  let(:replication_group_id) { "dev-redis-rep-group" }
+  let(:replica_cluster_id) { "dev-redis-replica" }
+
+  context '#create' do
+
+    let(:request) { CloudFormation::Bridge::Request.new(parse_json("create-replica-cluster-message", false)) }
+
+    it 'creates the cluster' do
+      expect(subject.client).to receive(:create_cache_cluster).
+                                  with(cache_cluster_id: replica_cluster_id, replication_group_id: replication_group_id)
+      expect(subject.client).to receive(:describe_cache_clusters).
+                                  with(cache_cluster_id: replica_cluster_id,
+                                       show_cache_node_info: true).twice.and_return(available)
+
+      outputs = subject.create(request)
+
+      expect(outputs).to eq(
+                           {
+                             FIELDS::DATA => {
+                               ELASTI_CACHE::REPLICA_CLUSTER_ID => replica_cluster_id,
+                               ELASTI_CACHE::NODE_URLS => "dev-redis-replica.mzufvw.0001.use1.cache.amazonaws.com:6379,dev-redis-replica.mzufvw.0002.use1.cache.amazonaws.com:6379",
+                             },
+                             FIELDS::PHYSICAL_RESOURCE_ID => replica_cluster_id,
+                           }
+                         )
+    end
+
+  end
+
+  context '#delete' do
+
+    let(:request) { CloudFormation::Bridge::Request.new(parse_json("delete-replica-cluster-message", false)) }
+
+    it 'deletes the cluster' do
+      expect(subject.client).to receive(:delete_cache_cluster).with(cache_cluster_id: replica_cluster_id)
+
+      count = 0
+
+      expect(subject.client).to receive(:describe_cache_clusters).
+                                  with(cache_cluster_id: replica_cluster_id,
+                                       show_cache_node_info: true).at_least(:once) do
+        if count == 0
+          count += 1
+          available
+        else
+          raise AWS::ElastiCache::Errors::CacheClusterNotFound
+        end
+      end
+
+      subject.delete(request)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,65 @@
+require 'cloud_formation/bridge/request'
+require 'cloud_formation/bridge/names'
+require 'cloud_formation/bridge/resources/elasti_cache_replication_group'
+
+describe CloudFormation::Bridge::Resources::ElastiCacheReplicationGroup do
+
+  include FileSupport
+
+  FIELDS = CloudFormation::Bridge::Names::FIELDS
+  ELASTI_CACHE = CloudFormation::Bridge::Names::ELASTI_CACHE
+
+  let(:replication_group_id) { "dev-redis-rep" }
+
+  def stub_describe_replication_group
+    expect(subject.client).to receive(:describe_replication_groups).
+                                with(replication_group_id: replication_group_id).
+                                and_return(parse_json("describe-replication-group-primary-only"))
+  end
+
+  context "#create" do
+
+    let(:request) { CloudFormation::Bridge::Request.new(parse_json("create-replication-group-message", false)) }
+
+    it 'creates the replication group' do
+      expect(subject.client).to receive(:create_replication_group).with(
+                                  replication_group_id: replication_group_id,
+                                  primary_cluster_id: "cluster-id-here",
+                                  replication_group_description: "Sample replication group for the redis instances",
+                                )
+
+      stub_describe_replication_group
+
+      outputs = subject.create(request)
+
+      expect(outputs).to eq(
+                           FIELDS::DATA => {
+                             ELASTI_CACHE::REPLICATION_GROUP_ID => replication_group_id,
+                           },
+                           FIELDS::PHYSICAL_RESOURCE_ID => replication_group_id,
+                         )
+    end
+
+  end
+
+  context "#delete" do
+
+    let(:request) { CloudFormation::Bridge::Request.new(parse_json("delete-replication-group-message", false)) }
+
+    it 'should delete the group' do
+      stub_describe_replication_group
+      expect(subject.client).to receive(:delete_replication_group).with(
+                                  replication_group_id: replication_group_id,
+                                  retain_primary_cluster: true,
+                                )
+      subject.delete(request)
+    end
+
+    it 'should ignore if the replication group does not exist' do
+      expect(subject).to receive(:replication_group_available?).and_raise(AWS::ElastiCache::Errors::ReplicationGroupNotFoundFault)
+      expect { subject.delete(request) }.not_to raise_error
+    end
+
+  end
+
+end

data/spec/support/file_support.rb

@@ -1,7 +1,13 @@
+require 'json'
+
 module FileSupport
 
   def read_file(name)
     IO.read(File.join(File.dirname(__FILE__), '..', 'files', name))
   end
 
+  def parse_json(name, symbolize_names = true)
+    JSON.parse(read_file("#{name}.json"), symbolize_names: symbolize_names)
+  end
+
 end