fog-aws 0.0.5

data/tests/requests/elasticache/describe_events.rb

@@ -0,0 +1,17 @@
+Shindo.tests('AWS::Elasticache | describe cache cluster events',
+  ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests(
+    '#describe_events'
+    ).formats(AWS::Elasticache::Formats::EVENT_LIST) do
+      Fog::AWS[:elasticache].describe_events().body['Events']
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+  end
+end

data/tests/requests/elasticache/describe_reserved_cache_nodes.rb

@@ -0,0 +1,17 @@
+Shindo.tests('AWS::Elasticache | describe reserved cache nodes',
+  ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests(
+    '#describe_reserved_cache_nodes'
+    ).formats(AWS::Elasticache::Formats::RESERVED_CACHE_NODES) do
+      Fog::AWS[:elasticache].describe_reserved_cache_nodes().body['ReservedCacheNodes']
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+  end
+end

data/tests/requests/elasticache/helper.rb

@@ -0,0 +1,103 @@
+class AWS
+  module Elasticache
+    module Formats
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      # Cache Security Groups
+      SECURITY_GROUP = {
+        'EC2SecurityGroups'       => Array,
+        'CacheSecurityGroupName'  => String,
+        'Description'             => String,
+        'OwnerId'                 => String,
+      }
+      SINGLE_SECURITY_GROUP = BASIC.merge('CacheSecurityGroup' => SECURITY_GROUP)
+      DESCRIBE_SECURITY_GROUPS = {'CacheSecurityGroups' => [SECURITY_GROUP]}
+
+      CACHE_SUBNET_GROUP = {
+        'CacheSubnetGroupName' => String,
+        'CacheSubnetGroupDescription' => String,
+        'VpcId' => String,
+        'Subnets' => [String]
+      }
+
+      CREATE_CACHE_SUBNET_GROUP = BASIC.merge({
+         'CreateCacheSubnetGroupResult' => {
+           'CacheSubnetGroup' => CACHE_SUBNET_GROUP
+         }
+       })
+
+      DESCRIBE_CACHE_SUBNET_GROUPS = BASIC.merge({
+        'DescribeCacheSubnetGroupsResult' => {
+          'CacheSubnetGroups' => [CACHE_SUBNET_GROUP]
+        }
+      })
+
+      # Cache Parameter Groups
+      PARAMETER_GROUP = {
+        'CacheParameterGroupFamily' => String,
+        'CacheParameterGroupName'   => String,
+        'Description'               => String,
+      }
+      SINGLE_PARAMETER_GROUP = BASIC.merge('CacheParameterGroup' => PARAMETER_GROUP)
+      DESCRIBE_PARAMETER_GROUPS = BASIC.merge('CacheParameterGroups' => [PARAMETER_GROUP])
+      MODIFY_PARAMETER_GROUP = {'CacheParameterGroupName' => String }
+      PARAMETER_SET = {
+        'Parameters'                      => Array,
+        'CacheNodeTypeSpecificParameters' => Array,
+      }
+      ENGINE_DEFAULTS = PARAMETER_SET.merge('CacheParameterGroupFamily' => String)
+      # Cache Clusters - more parameters get added as the lifecycle progresses
+      CACHE_CLUSTER = {
+        'AutoMinorVersionUpgrade'     => String,  # actually TrueClass or FalseClass
+        'CacheSecurityGroups'         => Array,
+        'CacheClusterId'              => String,
+        'CacheClusterStatus'          => String,
+        'CacheNodeType'               => String,
+        'Engine'                      => String,
+        'EngineVersion'               => String,
+        'CacheParameterGroup'         => Hash,
+        'NumCacheNodes'               => Integer,
+        'PreferredMaintenanceWindow'  => String,
+        'CacheNodes'                  => Array,
+        'PendingModifiedValues'       => Hash,
+      }
+      CACHE_CLUSTER_RUNNING   = CACHE_CLUSTER.merge({
+        'CacheClusterCreateTime'      => DateTime,
+        'PreferredAvailabilityZone'   => String,
+      })
+      CACHE_CLUSTER_MODIFIED  = CACHE_CLUSTER_RUNNING.merge({
+        'NotificationConfiguration'   => Hash,
+        'PendingModifiedValues'       => Hash,
+      })
+      SINGLE_CACHE_CLUSTER    = BASIC.merge('CacheCluster' => CACHE_CLUSTER)
+      DESCRIBE_CACHE_CLUSTERS = BASIC.merge('CacheClusters' => [CACHE_CLUSTER])
+
+      EVENT = {
+        'Date'                        => DateTime,
+        'Message'                     => String,
+        'SourceIdentifier'            => String,
+        'SourceType'                  => String,
+      }
+      EVENT_LIST = [EVENT]
+
+      RESERVED_CACHE_CLUSTER = {
+        'CacheNodeCount'                => Integer,
+        'CacheNodeType'                 => String,
+        'Duration'                      => Integer,
+        'FixedPrice'                    => Float,
+        'OfferingType'                  => String,
+        'ProductDescription'            => String,
+        'RecurringCharges'              => Array,
+        'ReservedCacheNodeId'           => String,
+        'ReservedCacheNodesOfferingId'  => String,
+        'StartTime'                     => DateTime,
+        'State'                         => String,
+        'UsagePrice'                    => Float
+      }
+      RESERVED_CACHE_CLUSTER_LIST = [RESERVED_CACHE_CLUSTER]
+
+    end
+  end
+end

data/tests/requests/elasticache/parameter_group_tests.rb

@@ -0,0 +1,105 @@
+Shindo.tests('AWS::Elasticache | parameter group requests', ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    name = 'fog-test'
+    description = 'Fog Test Parameter Group'
+
+    tests(
+    '#describe_engine_default_parameters'
+    ).formats(AWS::Elasticache::Formats::ENGINE_DEFAULTS) do
+      response = Fog::AWS[:elasticache].describe_engine_default_parameters
+      engine_defaults = response.body['EngineDefaults']
+      returns('memcached1.4') { engine_defaults['CacheParameterGroupFamily'] }
+      engine_defaults
+    end
+
+    tests(
+    '#create_cache_parameter_group'
+    ).formats(AWS::Elasticache::Formats::SINGLE_PARAMETER_GROUP) do
+      body = Fog::AWS[:elasticache].create_cache_parameter_group(name, description).body
+      group = body['CacheParameterGroup']
+      returns(name)           { group['CacheParameterGroupName'] }
+      returns(description)    { group['Description'] }
+      returns('memcached1.4') { group['CacheParameterGroupFamily'] }
+      body
+    end
+
+    tests(
+    '#describe_cache_parameters'
+    ).formats(AWS::Elasticache::Formats::PARAMETER_SET) do
+      response = Fog::AWS[:elasticache].describe_cache_parameters(name)
+      parameter_set = response.body['DescribeCacheParametersResult']
+      parameter_set
+    end
+
+    tests(
+    '#describe_cache_parameter_groups without options'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_PARAMETER_GROUPS) do
+      body = Fog::AWS[:elasticache].describe_cache_parameter_groups.body
+      returns(true, "has #{name}") do
+        body['CacheParameterGroups'].any? do |group|
+          group['CacheParameterGroupName'] == name
+        end
+      end
+      body
+    end
+
+    tests(
+    '#reset_cache_parameter_group completely'
+    ).formats('CacheParameterGroupName' => String) do
+      result = Fog::AWS[:elasticache].reset_cache_parameter_group(
+        name
+      ).body['ResetCacheParameterGroupResult']
+      returns(name) {result['CacheParameterGroupName']}
+      result
+    end
+
+    tests(
+    '#modify_cache_parameter_group'
+    ).formats('CacheParameterGroupName' => String) do
+      result = Fog::AWS[:elasticache].modify_cache_parameter_group(
+        name, {"chunk_size" => 32}
+      ).body['ModifyCacheParameterGroupResult']
+      returns(name) {result['CacheParameterGroupName']}
+      result
+    end
+
+    # BUG: returns "MalformedInput - Unexpected complex element termination"
+    tests(
+    '#reset_cache_parameter_group with one parameter'
+    ).formats('CacheParameterGroupName' => String) do
+      pending
+      result = Fog::AWS[:elasticache].reset_cache_parameter_group(
+        name, ["chunk_size"]
+      ).body['ResetCacheParameterGroupResult']
+      returns(name) {result['CacheParameterGroupName']}
+      result
+    end
+
+    tests(
+    '#describe_cache_parameter_groups with name'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_PARAMETER_GROUPS) do
+      body = Fog::AWS[:elasticache].describe_cache_parameter_groups(name).body
+      returns(1, "size of 1") { body['CacheParameterGroups'].size }
+      returns(name, "has #{name}") do
+        body['CacheParameterGroups'].first['CacheParameterGroupName']
+      end
+      body
+    end
+
+    tests(
+    '#delete_cache_parameter_group'
+    ).formats(AWS::Elasticache::Formats::BASIC) do
+      body = Fog::AWS[:elasticache].delete_cache_parameter_group(name).body
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+    # Create a duplicate parameter group
+    # List a missing parameter group
+    # Delete a missing parameter group
+  end
+end

data/tests/requests/elasticache/security_group_tests.rb

@@ -0,0 +1,108 @@
+Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache']) do
+
+  tests('success') do
+
+    name = 'fog-test'
+    description = 'Fog Test Security Group'
+
+    tests(
+    '#create_cache_security_group'
+    ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+      body = Fog::AWS[:elasticache].create_cache_security_group(name, description).body
+      group = body['CacheSecurityGroup']
+      returns(name)        { group['CacheSecurityGroupName'] }
+      returns(description) { group['Description'] }
+      returns([], "no authorized security group") { group['EC2SecurityGroups'] }
+      body
+    end
+
+    tests(
+    '#describe_cache_security_groups without options'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_SECURITY_GROUPS) do
+      body = Fog::AWS[:elasticache].describe_cache_security_groups.body
+      returns(true, "has #{name}") do
+        body['CacheSecurityGroups'].any? do |group|
+          group['CacheSecurityGroupName'] == name
+        end
+      end
+      body
+    end
+
+    tests(
+    '#describe_cache_security_groups with name'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_SECURITY_GROUPS) do
+      body = Fog::AWS[:elasticache].describe_cache_security_groups(name).body
+      returns(1, "size of 1") { body['CacheSecurityGroups'].size }
+      returns(name, "has #{name}") do
+        body['CacheSecurityGroups'].first['CacheSecurityGroupName']
+      end
+      body
+    end
+
+    tests('authorization') do
+      ec2_group = Fog::Compute.new(:provider => 'AWS').security_groups.create(
+        :name => 'fog-test-elasticache', :description => 'Fog Test Elasticache'
+      )
+      # Reload to get the owner_id
+      ec2_group.reload
+
+      tests(
+      '#authorize_cache_security_group_ingress'
+      ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+        body = Fog::AWS[:elasticache].authorize_cache_security_group_ingress(
+          name, ec2_group.name, ec2_group.owner_id
+        ).body
+        group = body['CacheSecurityGroup']
+        expected_ec2_groups = [{
+          'Status' => 'authorizing', 'EC2SecurityGroupName' => ec2_group.name,
+          'EC2SecurityGroupOwnerId' => ec2_group.owner_id
+        }]
+        returns(expected_ec2_groups, 'has correct EC2 groups') do
+          group['EC2SecurityGroups']
+        end
+        body
+      end
+
+      # Wait for the state to be active
+      Fog.wait_for do
+        response = Fog::AWS[:elasticache].describe_cache_security_groups(name)
+        group = response.body['CacheSecurityGroups'].first
+        group['EC2SecurityGroups'].all? {|ec2| ec2['Status'] == 'authorized'}
+      end
+
+      tests(
+      '#revoke_cache_security_group_ingress'
+      ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+        pending if Fog.mocking?
+
+        body = Fog::AWS[:elasticache].revoke_cache_security_group_ingress(
+          name, ec2_group.name, ec2_group.owner_id
+        ).body
+        group = body['CacheSecurityGroup']
+        expected_ec2_groups = [{
+          'Status' => 'revoking', 'EC2SecurityGroupName' => ec2_group.name,
+          'EC2SecurityGroupOwnerId' => ec2_group.owner_id
+        }]
+        returns(expected_ec2_groups, 'has correct EC2 groups') do
+          group['EC2SecurityGroups']
+        end
+        body
+      end
+
+      ec2_group.destroy
+    end
+
+    tests(
+    '#delete_cache_security_group'
+    ).formats(AWS::Elasticache::Formats::BASIC) do
+      body = Fog::AWS[:elasticache].delete_cache_security_group(name).body
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+    # Create a duplicate security group
+    # List a missing security group
+    # Delete a missing security group
+  end
+end

data/tests/requests/elasticache/subnet_group_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests('AWS::Elasticache | subnet group requests', ['aws', 'elasticache']) do
+  # random_differentiator
+  # Useful when rapidly re-running tests, so we don't have to wait
+  # serveral minutes for deleted VPCs/subnets to disappear
+  suffix = rand(65536).to_s(16)
+  @subnet_group_name = "fog-test-#{suffix}"
+
+  vpc_range = rand(245) + 10
+  @vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => "10.#{vpc_range}.0.0/16")
+
+  # Create 4 subnets in this VPC, each one in a different AZ
+  subnet_az = 'us-east-1a'
+  subnet_range = 8
+  @subnets = (1..4).map do
+    subnet = Fog::Compute[:aws].create_subnet(@vpc.id, "10.#{vpc_range}.#{subnet_range}.0/24",
+      'AvailabilityZone' => subnet_az).body['subnet']
+    subnet_az = subnet_az.succ
+    subnet_range *= 2
+    subnet
+  end
+
+  tests('success') do
+
+    subnet_ids = @subnets.map { |sn| sn['subnetId'] }.to_a
+
+    tests("#create_cache_subnet_group").formats(AWS::Elasticache::Formats::CREATE_CACHE_SUBNET_GROUP) do
+      result = Fog::AWS[:elasticache].create_cache_subnet_group(@subnet_group_name, subnet_ids, 'A subnet group').body
+
+      returns(@subnet_group_name) { result['CreateCacheSubnetGroupResult']['CacheSubnetGroup']['CacheSubnetGroupName'] }
+      returns('A subnet group') { result['CreateCacheSubnetGroupResult']['CacheSubnetGroup']['CacheSubnetGroupDescription'] }
+      returns(@vpc.id) { result['CreateCacheSubnetGroupResult']['CacheSubnetGroup']['VpcId'] }
+      returns(subnet_ids.sort) { result['CreateCacheSubnetGroupResult']['CacheSubnetGroup']['Subnets'].sort }
+
+      result
+    end
+
+    tests("#describe_cache_subnet_groups").formats(AWS::Elasticache::Formats::DESCRIBE_CACHE_SUBNET_GROUPS) do
+      Fog::AWS[:elasticache].describe_cache_subnet_groups.body
+    end
+
+    tests("#delete_cache_subnet_group").formats(AWS::Elasticache::Formats::BASIC) do
+      Fog::AWS[:elasticache].delete_cache_subnet_group(@subnet_group_name).body
+    end
+
+  end
+
+  @subnets.each do |sn|
+    Fog::Compute[:aws].delete_subnet(sn['subnetId'])
+  end
+  @vpc.destroy
+
+end

data/tests/requests/elb/helper.rb

@@ -0,0 +1,91 @@
+class AWS
+  module ELB
+    module Formats
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      LOAD_BALANCER = {
+        "AvailabilityZones" => Array,
+        "BackendServerDescriptions" => Array,
+        "CanonicalHostedZoneName" => String,
+        "CanonicalHostedZoneNameID" => String,
+        "CreatedTime" => Time,
+        "DNSName" => String,
+        "HealthCheck" => {"HealthyThreshold" => Integer, "Timeout" => Integer, "UnhealthyThreshold" => Integer, "Interval" => Integer, "Target" => String},
+        "Instances" => Array,
+        "ListenerDescriptions" => [{
+          'PolicyNames' => Array,
+          'Listener' => {
+            'InstancePort' => Integer,
+            'InstanceProtocol' => String,
+            'LoadBalancerPort' => Integer,
+            'Protocol' => String,
+            'SSLCertificateId' => Fog::Nullable::String
+          }
+        }],
+        "LoadBalancerName" => String,
+        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array, "OtherPolicies" => Array},
+        "Scheme" => String,
+        "SecurityGroups" => [Fog::Nullable::String],
+        "SourceSecurityGroup" => {"GroupName" => String, "OwnerAlias" => String},
+        "Subnets" => [Fog::Nullable::String]
+      }
+
+      CREATE_LOAD_BALANCER = BASIC.merge({
+        'CreateLoadBalancerResult' => { 'DNSName' => String }
+      })
+
+      DESCRIBE_LOAD_BALANCERS = BASIC.merge({
+        'DescribeLoadBalancersResult' => {'LoadBalancerDescriptions' => [LOAD_BALANCER], 'NextMarker' => Fog::Nullable::String}
+      })
+
+      POLICY_ATTRIBUTE_DESCRIPTION = {
+        "AttributeName" => String,
+        "AttributeValue" => String
+      }
+
+      POLICY = {
+        "PolicyAttributeDescriptions" => [POLICY_ATTRIBUTE_DESCRIPTION],
+        "PolicyName" => String,
+        "PolicyTypeName" => String
+      }
+
+      DESCRIBE_LOAD_BALANCER_POLICIES = BASIC.merge({
+        'DescribeLoadBalancerPoliciesResult' => { 'PolicyDescriptions' => [POLICY] }
+      })
+
+      POLICY_ATTRIBUTE_TYPE_DESCRIPTION = {
+        "AttributeName" => String,
+        "AttributeType" => String,
+        "Cardinality" => String,
+        "DefaultValue" => String,
+        "Description" => String
+      }
+
+      POLICY_TYPE = {
+        "Description" => String,
+        "PolicyAttributeTypeDescriptions" => [POLICY_ATTRIBUTE_TYPE_DESCRIPTION],
+        "PolicyTypeName" => String
+      }
+
+      DESCRIBE_LOAD_BALANCER_POLICY_TYPES = BASIC.merge({
+        'DescribeLoadBalancerPolicyTypesResult' => {'PolicyTypeDescriptions' => [POLICY_TYPE] }
+      })
+
+      CONFIGURE_HEALTH_CHECK = BASIC.merge({
+        'ConfigureHealthCheckResult' => {'HealthCheck' => {
+        'Target' => String,
+        'Interval' => Integer,
+        'Timeout' => Integer,
+        'UnhealthyThreshold' => Integer,
+        'HealthyThreshold' => Integer
+      }}
+      })
+
+      DELETE_LOAD_BALANCER = BASIC.merge({
+        'DeleteLoadBalancerResult' =>  NilClass
+      })
+    end
+  end
+end