fog-aws 3.5.2 → 3.19.0

data/tests/requests/elasticache/parameter_group_tests.rb

@@ -1,105 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

data/tests/requests/elb/listener_tests.rb

@@ -1,68 +0,0 @@
-Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
-  @load_balancer_id = 'fog-test-listener'
-  @key_name = 'fog-test'
-
-  tests('success') do
-    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, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
-
-    tests("#create_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
-      listeners = [
-        {'Protocol' => 'TCP', 'InstanceProtocol' => 'TCP', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
-        {'Protocol' => 'HTTP', 'InstanceProtocol' => 'HTTP', 'LoadBalancerPort' => 80, 'InstancePort' => 80}
-      ]
-      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]
-      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', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => 'non-existant'},
-      ]
-      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
-      sleep 8 unless Fog.mocking?
-      listeners = [
-        {'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => "#{@certificate['Arn']}fake"},
-      ]
-      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
-    tests("#create_load_balancer_listeners with SSL certificate").formats(AWS::ELB::Formats::BASIC) do
-      sleep 8 unless Fog.mocking?
-      listeners = [
-        {'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
-      ]
-      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
-    end
-
-    tests("#set_load_balancer_listener_ssl_certificate").formats(AWS::ELB::Formats::BASIC) do
-      Fog::AWS[:elb].set_load_balancer_listener_ssl_certificate(@load_balancer_id, 443, @certificate['Arn']).body
-    end
-
-    tests("#create_load_balancer_listeners with invalid Protocol and InstanceProtocol configuration").raises(Fog::AWS::ELB::ValidationError) do
-      listeners = [
-        {'Protocol' => 'HTTP', 'InstanceProtocol' => 'TCP', 'LoadBalancerPort' => 80, 'InstancePort' => 80},
-      ]
-      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
-    end
-
-    tests("#create_load_balancer_listeners with valid Protocol and InstanceProtocol configuration").formats(AWS::ELB::Formats::BASIC) do
-      listeners = [
-        {'Protocol' => 'HTTP', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 80, 'InstancePort' => 80},
-      ]
-      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
-    end
-
-    Fog::AWS[:iam].delete_server_certificate(@key_name)
-    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
-  end
-end

data/tests/requests/elb/load_balancer_tests.rb

@@ -1,89 +0,0 @@
-Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
-  @load_balancer_id = 'fog-test-elb'
-  @key_name = 'fog-test'
-
-  tests('success') do
-    if (Fog::AWS[:iam].get_server_certificate(@key_name) rescue nil)
-      Fog::AWS[:iam].delete_server_certificate(@key_name)
-    end
-
-    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT, 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, 'InstanceProtocol' => 'HTTP', 'Protocol' => 'HTTP'}]
-      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
-      Fog::AWS[:elb].describe_load_balancers.body
-    end
-
-    tests('#describe_load_balancers with bad lb') do
-      raises(Fog::AWS::ELB::NotFound) { Fog::AWS[:elb].describe_load_balancers('LoadBalancerNames' => 'none-such-lb') }
-    end
-
-    tests("#describe_load_balancers with SSL listener") do
-      sleep 5 unless Fog.mocking?
-      listeners = [
-        {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
-      ]
-      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners)
-      response = Fog::AWS[:elb].describe_load_balancers('LoadBalancerNames' => @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"]
-      end
-    end
-
-    tests("modify_load_balancer_attributes") do
-      attributes = {
-        'ConnectionDraining' => {'Enabled' => true, 'Timeout' => 600},
-        'CrossZoneLoadBalancing' => {'Enabled' => true},
-        'ConnectionSettings' => {'IdleTimeout' => 180}
-      }
-      Fog::AWS[:elb].modify_load_balancer_attributes(@load_balancer_id, attributes).body
-      response = Fog::AWS[:elb].describe_load_balancer_attributes(@load_balancer_id).
-        body['DescribeLoadBalancerAttributesResult']['LoadBalancerAttributes']
-
-      tests("ConnectionDraining is enabled") do
-        response['ConnectionDraining']['Enabled'] == true
-      end
-      tests("ConnectionDraining has a 600 second Timeout").returns(600) do
-        response['ConnectionDraining']['Timeout']
-      end
-      tests("ConnectionSettings has a 180 second IdleTimeout").returns(180) do
-        response['ConnectionSettings']['IdleTimeout']
-      end
-      tests("CrossZoneLoadBalancing is enabled") do
-        response['CrossZoneLoadBalancing']['Enabled'] == true
-      end
-    end
-
-    tests("#configure_health_check").formats(AWS::ELB::Formats::CONFIGURE_HEALTH_CHECK) do
-      health_check = {
-        'Target' => 'HTTP:80/index.html',
-        'Interval' => 10,
-        'Timeout' => 5,
-        'UnhealthyThreshold' => 2,
-        'HealthyThreshold' => 3
-      }
-
-      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
-      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
-      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
-      Fog::AWS[:elb].delete_load_balancer(@load_balancer_id).body
-    end
-
-    Fog::AWS[:iam].delete_server_certificate(@key_name)
-  end
-end

data/tests/requests/elb/policy_tests.rb

@@ -1,132 +0,0 @@
-Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
-  @load_balancer_id = 'fog-test-policies'
-
-  tests('success') do
-    listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
-    Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, listeners)
-
-    tests("#describe_load_balancer_policy_types").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICY_TYPES) do
-      @policy_types = Fog::AWS[:elb].describe_load_balancer_policy_types.body
-    end
-
-    tests("#create_app_cookie_stickiness_policy").formats(AWS::ELB::Formats::BASIC) do
-      cookie, policy = 'fog-app-cookie', 'fog-app-policy'
-      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
-      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'
-      Fog::AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy).body
-    end
-
-    tests("#create_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
-      policy = 'fog-policy'
-      Fog::AWS[:elb].create_load_balancer_policy(@load_balancer_id, policy, 'PublicKeyPolicyType', {'PublicKey' => AWS::IAM::SERVER_CERT_PUBLIC_KEY}).body
-    end
-
-    tests("#describe_load_balancer_policies") do
-      body = Fog::AWS[:elb].describe_load_balancer_policies(@load_balancer_id).body
-      formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICIES) { body }
-
-      # Check the result of each policy by name
-      returns({
-                "PolicyAttributeDescriptions"=>[{
-                                                  "AttributeName"=>"CookieName",
-                                                  "AttributeValue"=>"fog-app-cookie"
-                                                }],
-                "PolicyName"=>"fog-app-policy",
-                "PolicyTypeName"=>"AppCookieStickinessPolicyType"
-              }) do
-        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-app-policy' }
-      end
-
-      returns({
-                "PolicyAttributeDescriptions"=>[{
-                                                  "AttributeName"=>"CookieExpirationPeriod",
-                                                  "AttributeValue"=>"300"
-                                                }],
-                "PolicyName"=>"fog-lb-expiry",
-                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
-              }) do
-        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-lb-expiry' }
-      end
-
-      returns({
-                "PolicyAttributeDescriptions"=>[{
-                                                  "AttributeName"=>"CookieExpirationPeriod",
-                                                  "AttributeValue"=>"0"
-                                                }],
-                "PolicyName"=>"fog-lb-no-expiry",
-                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
-              }) do
-        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-lb-no-expiry' }
-      end
-
-      returns({
-                "PolicyAttributeDescriptions"=>[{
-                                                  "AttributeName"=>"PublicKey",
-                                                  "AttributeValue"=> AWS::IAM::SERVER_CERT_PUBLIC_KEY
-                                                }],
-                "PolicyName"=>"fog-policy",
-                "PolicyTypeName"=>"PublicKeyPolicyType"
-              }) do
-        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-policy' }
-      end
-    end
-
-    tests("#describe_load_balancer includes all policies") do
-      lb = Fog::AWS[:elb].describe_load_balancers("LoadBalancerNames" => [@load_balancer_id]).body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
-      returns([
-               {"PolicyName"=>"fog-app-policy", "CookieName"=>"fog-app-cookie"}
-              ]) { lb["Policies"]["AppCookieStickinessPolicies"] }
-
-      returns([
-               {"PolicyName"=>"fog-lb-expiry", "CookieExpirationPeriod"=> 300}
-              ]) { lb["Policies"]["LBCookieStickinessPolicies"].select{|e| e["PolicyName"] == "fog-lb-expiry"} }
-
-      returns([
-               {"PolicyName" => "fog-lb-no-expiry"}
-              ]) { lb["Policies"]["LBCookieStickinessPolicies"].select{|e| e["PolicyName"] == "fog-lb-no-expiry"} }
-
-      returns([
-               "fog-policy"
-              ]) { lb["Policies"]["OtherPolicies"] }
-    end
-
-    tests("#delete_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
-      policy = 'fog-lb-no-expiry'
-      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']
-      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
-      Fog::AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, []).body
-    end
-
-    proxy_policy = "EnableProxyProtocol"
-    Fog::AWS[:elb].create_load_balancer_policy(@load_balancer_id, proxy_policy, 'ProxyProtocolPolicyType', { "ProxyProtocol" => true })
-
-    tests("#set_load_balancer_policies_for_backend_server replaces policies on port").formats(AWS::ELB::Formats::BASIC) do
-      Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(@load_balancer_id, 80, [proxy_policy]).body
-    end
-
-    tests("#describe_load_balancers has other policies") do
-      Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(@load_balancer_id, 80, [proxy_policy]).body
-      description = Fog::AWS[:elb].describe_load_balancers("LoadBalancerNames" => [@load_balancer_id]).body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
-      returns(true) { description["Policies"]["OtherPolicies"].include?(proxy_policy) }
-    end
-
-    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
-  end
-end