fog 0.11.0 → 1.0.0

data/tests/aws/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
+      AWS[:elasticache].describe_events().body['Events']
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+  end
+end

data/tests/aws/requests/elasticache/helper.rb

@@ -0,0 +1,68 @@
+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 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]
+    end
+  end
+end

data/tests/aws/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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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/aws/requests/elasticache/security_group_tests.rb

@@ -0,0 +1,107 @@
+Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    name = 'fog-test'
+    description = 'Fog Test Group'
+
+    tests(
+    '#create_cache_security_group'
+    ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+      body = 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 = 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 = 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 = 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 = 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
+        body = 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 = 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/aws/requests/elb/listener_tests.rb

@@ -3,28 +3,28 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
   @key_name = 'fog-test'
 
   tests('success') do
-    AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}])
-    @certificate = AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+    Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}])
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
 
     tests("#create_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
       listeners = [
         {'Protocol' => 'TCP', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
         {'Protocol' => 'HTTP', 'LoadBalancerPort' => 80, 'InstancePort' => 80}
       ]
-      response = AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+      response = Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
       response
     end
 
     tests("#delete_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
       ports = [80, 443]
-      AWS[:elb].delete_load_balancer_listeners(@load_balancer_id, ports).body
+      Fog::AWS[:elb].delete_load_balancer_listeners(@load_balancer_id, ports).body
     end
 
     tests("#create_load_balancer_listeners with non-existant SSL certificate") do
       listeners = [
         {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => 'non-existant'},
       ]
-      raises(Fog::AWS::IAM::NotFound) { AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners) }
+      raises(Fog::AWS::IAM::NotFound) { Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners) }
     end
 
     tests("#create_load_balancer_listeners with invalid SSL certificate").raises(Fog::AWS::IAM::NotFound) do
@@ -32,7 +32,7 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
       listeners = [
         {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => "#{@certificate['Arn']}fake"},
       ]
-      AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
     end
 
     # This is sort of fucked up, but it may or may not fail, thanks AWS
@@ -41,10 +41,10 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
       listeners = [
         {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
       ]
-      AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
     end
 
-    AWS[:iam].delete_server_certificate(@key_name)
-    AWS[:elb].delete_load_balancer(@load_balancer_id)
+    Fog::AWS[:iam].delete_server_certificate(@key_name)
+    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
   end
 end

data/tests/aws/requests/elb/load_balancer_tests.rb

@@ -3,20 +3,20 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
   @key_name = 'fog-test'
 
   tests('success') do
-    @certificate = AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
 
     tests("#create_load_balancer").formats(AWS::ELB::Formats::CREATE_LOAD_BALANCER) do
       zones = ['us-east-1a']
       listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
-      AWS[:elb].create_load_balancer(zones, @load_balancer_id, listeners).body
+      Fog::AWS[:elb].create_load_balancer(zones, @load_balancer_id, listeners).body
     end
 
     tests("#describe_load_balancers").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCERS) do
-      AWS[:elb].describe_load_balancers.body
+      Fog::AWS[:elb].describe_load_balancers.body
     end
 
     tests('#describe_load_balancers with bad lb') do
-      raises(Fog::AWS::ELB::NotFound) { AWS[:elb].describe_load_balancers('none-such-lb') }
+      raises(Fog::AWS::ELB::NotFound) { Fog::AWS[:elb].describe_load_balancers('none-such-lb') }
     end
 
     tests("#describe_load_balancers with SSL listener") do
@@ -24,8 +24,8 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
       listeners = [
         {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
       ]
-      AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners)
-      response = AWS[:elb].describe_load_balancers(@load_balancer_id).body
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners)
+      response = Fog::AWS[:elb].describe_load_balancers(@load_balancer_id).body
       tests("SSLCertificateId is set").returns(@certificate['Arn']) do
         listeners = response["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first["ListenerDescriptions"]
         listeners.find {|l| l["Listener"]["Protocol"] == 'HTTPS' }["Listener"]["SSLCertificateId"]
@@ -41,21 +41,21 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
         'HealthyThreshold' => 3
       }
 
-      AWS[:elb].configure_health_check(@load_balancer_id, health_check).body
+      Fog::AWS[:elb].configure_health_check(@load_balancer_id, health_check).body
     end
 
     tests("#delete_load_balancer").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
-      AWS[:elb].delete_load_balancer(@load_balancer_id).body
+      Fog::AWS[:elb].delete_load_balancer(@load_balancer_id).body
     end
 
     tests("#delete_load_balancer when non existant").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
-      AWS[:elb].delete_load_balancer('non-existant').body
+      Fog::AWS[:elb].delete_load_balancer('non-existant').body
     end
 
     tests("#delete_load_balancer when already deleted").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
-      AWS[:elb].delete_load_balancer(@load_balancer_id).body
+      Fog::AWS[:elb].delete_load_balancer(@load_balancer_id).body
     end
 
-    AWS[:iam].delete_server_certificate(@key_name)
+    Fog::AWS[:iam].delete_server_certificate(@key_name)
   end
 end

data/tests/aws/requests/elb/policy_tests.rb

@@ -3,39 +3,39 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
 
   tests('success') do
     listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
-    AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, listeners)
+    Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, listeners)
 
     tests("#create_app_cookie_stickiness_policy").formats(AWS::ELB::Formats::BASIC) do
       cookie, policy = 'fog-app-cookie', 'fog-app-policy'
-      AWS[:elb].create_app_cookie_stickiness_policy(@load_balancer_id, policy, cookie).body
+      Fog::AWS[:elb].create_app_cookie_stickiness_policy(@load_balancer_id, policy, cookie).body
     end
 
     tests("#create_lb_cookie_stickiness_policy with expiry").formats(AWS::ELB::Formats::BASIC) do
       policy = 'fog-lb-expiry'
       expiry = 300
-      AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy, expiry).body
+      Fog::AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy, expiry).body
     end
 
     tests("#create_lb_cookie_stickiness_policy without expiry").formats(AWS::ELB::Formats::BASIC) do
       policy = 'fog-lb-no-expiry'
-      AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy).body
+      Fog::AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy).body
     end
 
     tests("#delete_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
       policy = 'fog-lb-no-expiry'
-      AWS[:elb].delete_load_balancer_policy(@load_balancer_id, policy).body
+      Fog::AWS[:elb].delete_load_balancer_policy(@load_balancer_id, policy).body
     end
 
     tests("#set_load_balancer_policies_of_listener adds policy").formats(AWS::ELB::Formats::BASIC) do
       port, policies = 80, ['fog-lb-expiry']
-      AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, policies).body
+      Fog::AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, policies).body
     end
 
     tests("#set_load_balancer_policies_of_listener removes policy").formats(AWS::ELB::Formats::BASIC) do
       port = 80
-      AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, []).body
+      Fog::AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, []).body
     end
 
-    AWS[:elb].delete_load_balancer(@load_balancer_id)
+    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
   end
 end