fog 1.0.0 → 1.5.0

data/lib/fog/aws/requests/dynamodb/update_item.rb

@@ -0,0 +1,49 @@
+module Fog
+  module AWS
+    class DynamoDB
+      class Real
+
+        # Update DynamoDB item
+        #
+        # ==== Parameters
+        # * 'table_name'<~String> - name of table for item
+        # * 'key'<~Hash>:
+        #   * 'HashKeyElement'<~Hash>: info for primary key
+        #     * 'AttributeName'<~String> - name of attribute
+        #     * 'AttributeType'<~String> - type of attribute
+        #   * 'RangeKeyElement'<~Hash>: optional, info for range key
+        #     * 'AttributeName'<~String> - name of attribute
+        #     * 'AttributeType'<~String> - type of attribute
+        # * 'attribute_updates'<~Hash>:
+        #   * 'AttributeName'<~String> - Attribute to update
+        #     * 'Value'<~Hash> - formated as {type => value}
+        #     * 'Action'<~String> - action to take if expects matches, in %w{ADD DELETE PUT}, defaults to PUT
+        # * 'options'<~Hash>:
+        #   * 'Expected'<~Hash>: data to check against
+        #     * 'AttributeName'<~String> - name of attribute
+        #     * 'Value'<~Hash> - a value to check for the value of
+        #     or
+        #     * 'Exists'<~Boolean> - set as false to only allow update if attribute doesn't exist
+        #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     varies based on ReturnValues param, see: http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_UpdateItem.html
+        def update_item(table_name, key, attribute_updates, options = {})
+          body = {
+            'AttributeUpdates'  => attribute_updates,
+            'Key'               => key,
+            'TableName'         => table_name
+          }.merge(options)
+
+          request(
+            :body     => Fog::JSON.encode(body),
+            :headers  => {'x-amz-target' => 'DynamoDB_20111205.UpdateItem'}
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/dynamodb/update_table.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class DynamoDB
+      class Real
+
+        # Update DynamoDB table throughput
+        #
+        # ==== Parameters
+        # * 'table_name'<~String> - name of table to describe
+        # * 'provisioned_throughput'<~Hash>:
+        #   * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
+        #   * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Table'<~Hash>
+        #       * 'KeySchema'<~Hash> - schema for table
+        #         * 'HashKeyElement'<~Hash>: info for primary key
+        #           * 'AttributeName'<~String> - name of attribute
+        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
+        #         * 'RangeKeyElement'<~Hash>: optional, info for range key
+        #           * 'AttributeName'<~String> - name of attribute
+        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
+        #       * 'ProvisionedThroughput'<~Hash>:
+        #         * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
+        #         * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
+        #       * 'TableName'<~String> - name of table
+        #       * 'TableStatus'<~String> - status of table
+        def update_table(table_name, provisioned_throughput)
+          body = {
+            'ProvisionedThroughput' => provisioned_throughput,
+            'TableName'             => table_name
+          }
+
+          request(
+            :body       => Fog::JSON.encode(body),
+            :headers    => {'x-amz-target' => 'DynamoDB_20111205.UpdateTable'},
+            :idempotent => true
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elasticache/create_cache_cluster.rb

@@ -36,7 +36,7 @@ module Fog
           # Merge the Cache Security Group parameters with the normal options
           request(sec_group_params.merge(
             'Action'          => 'CreateCacheCluster',
-            'CacheClusterId'  => id,
+            'CacheClusterId'  => id.strip,
             'CacheNodeType'   => options[:node_type]  || 'cache.m1.large',
             'Engine'          => options[:engine]     || 'memcached',
             'NumCacheNodes'   => options[:num_nodes]  || 1,
@@ -54,9 +54,33 @@ module Fog
 
       class Mock
         def create_cache_cluster(id, options = {})
-          Fog::Mock.not_implemented
+          response        = Excon::Response.new
+          cluster         = { # create an in-memory representation of this cluster
+            'CacheClusterId'  => id.strip,
+            'NumCacheNodes'   => options[:num_nodes]      || 1,
+            'CacheNodeType'   => options[:node_type]      || 'cache.m1.large',
+            'Engine'          => options[:engine]         || 'memcached',
+            'EngineVersion'   => options[:engine_version] || '1.4.5',
+            'CacheClusterStatus'  => 'available',
+            'CacheNodes'          => create_cache_nodes(id.strip, options[:num_nodes]),
+            'CacheSecurityGroups' => [],
+            'CacheParameterGroup' => { 'CacheParameterGroupName' =>
+                options[:parameter_group_name] || 'default.memcached1.4' },
+            'PendingModifiedValues'       => {},
+            'AutoMinorVersionUpgrade'     =>
+              options[:auto_minor_version_upgrade]    || 'true',
+            'PreferredMaintenanceWindow'  =>
+              options[:preferred_maintenance_window]  || 'sun:05:00-sun:09:00',
+          }
+          self.data[:clusters][id] = cluster  # store the in-memory cluster
+          response.body = {
+            'CacheCluster' => cluster.merge({'CacheClusterStatus' => 'creating'}),
+            'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
+          }
+          response
         end
       end
+
     end
   end
 end

data/lib/fog/aws/requests/elasticache/delete_cache_cluster.rb

@@ -24,9 +24,18 @@ module Fog
 
       class Mock
         def delete_cache_cluster(cluster_id)
-          Fog::Mock.not_implemented
+          response        = Excon::Response.new
+          cluster         = self.data[:clusters][cluster_id]
+          cluster['CacheClusterStatus'] = 'deleting'
+          response.body = {
+            'CacheClusters'     => self.data[:clusters].values,
+            'ResponseMetadata'  => { 'RequestId' => Fog::AWS::Mock.request_id }
+          }
+          self.data[:clusters].delete(cluster_id)
+          response
         end
       end
+
     end
   end
 end

data/lib/fog/aws/requests/elasticache/describe_cache_clusters.rb

@@ -31,9 +31,24 @@ module Fog
 
       class Mock
         def describe_cache_clusters(id = nil, options = {})
-          Fog::Mock.not_implemented
+          response        = Excon::Response.new
+          all_clusters    = self.data[:clusters].values.map do |cluster|
+            cluster.merge!(options[:show_node_info] ? {
+              'CacheClusterCreateTime'    => DateTime.now - 60,
+              'PreferredAvailabilityZone' => 'us-east-1a'
+            } : {})
+          end
+          if (id != nil) && (all_clusters.empty?)
+            raise Fog::AWS::Elasticache::NotFound
+          end
+          response.body = {
+            'CacheClusters'     => all_clusters,
+            'ResponseMetadata'  => { 'RequestId' => Fog::AWS::Mock.request_id }
+          }
+          response
         end
       end
+
     end
   end
 end

data/lib/fog/aws/requests/elasticache/modify_cache_cluster.rb

@@ -45,7 +45,7 @@ module Fog
           # Merge the Cache Security Group parameters with the normal options
           request(node_id_params.merge(sec_group_params.merge(
             'Action'                      => 'ModifyCacheCluster',
-            'CacheClusterId'              => id,
+            'CacheClusterId'              => id.strip,
             'ApplyImmediately'            => options[:apply_immediately],
             'NumCacheNodes'               => options[:num_nodes],
             'AutoMinorVersionUpgrade'     => options[:auto_minor_version_upgrade],
@@ -61,10 +61,42 @@ module Fog
       end
 
       class Mock
-        def modify_cache_cluster
-          Fog::Mock.not_implemented
+        def modify_cache_cluster(id, options = {})
+          response        = Excon::Response.new
+          cluster         = self.data[:clusters][id]
+          pending_values  = Hash.new
+          # For any given option, update the cluster's corresponding value
+          { :auto_minor_version_upgrade   => 'AutoMinorVersionUpgrade',
+            :preferred_maintenance_window => 'PreferredMaintenanceWindow',
+            :engine_version               => 'EngineVersion',
+            :num_nodes                    => 'NumCacheNodes',
+          }.each do |option, cluster_key|
+            if options[option] != nil
+              cluster[cluster_key] = options[option].to_s
+              pending_values[cluster_key] = options[option]
+            end
+          end
+          cache['CacheParameterGroup'] = {
+            'CacheParameterGroupName' => options[:parameter_group_name]
+          } if options[:parameter_group_name]
+          if options[:num_nodes] || options[:engine_version]
+            cluster['CacheNodes'] =
+              create_cache_nodes(cluster['CacheClusterId'], options[:num_nodes])
+            cluster['NumCacheNodes'] = cluster['CacheNodes'].size
+          end
+          if options[:nodes_to_remove]
+            pending_values['CacheNodeId'] = options[:nodes_to_remove].join(',')
+          end
+          response.body = {
+            'CacheCluster' => cluster.merge({
+              'PendingModifiedValues' => pending_values
+            }),
+            'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
+          }
+          response
         end
       end
+
     end
   end
 end

data/lib/fog/aws/requests/elasticache/reboot_cache_cluster.rb

@@ -35,10 +35,18 @@ module Fog
       end
 
       class Mock
-        def reboot_cache_cluster
-          Fog::Mock.not_implemented
+        def reboot_cache_cluster(id, nodes_to_reboot)
+          response        = Excon::Response.new
+          response.body   = {
+            'CacheCluster' => self.data[:clusters][id].merge({
+              'CacheClusterStatus' => 'rebooting cache cluster nodes'
+            }),
+            'ResponseMetadata'  => { 'RequestId' => Fog::AWS::Mock.request_id }
+          }
+          response
         end
       end
+
     end
   end
 end

data/lib/fog/aws/requests/elb/apply_security_groups_to_load_balancer.rb

@@ -0,0 +1,61 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/apply_security_groups_to_load_balancer'
+
+        # Sets the security groups for an ELB in VPC
+        #
+        # ==== Parameters
+        # * security_group_ids<~Array> - List of security group ids to enable on ELB
+        # * lb_name<~String> - Load balancer to disable availability zones on
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'ApplySecurityGroupsToLoadBalancer'<~Hash>:
+        #       * 'SecurityGroups'<~Array> - array of strings describing the security group ids currently enabled
+        def apply_security_groups_to_load_balancer(security_group_ids, lb_name)
+          params = Fog::AWS.indexed_param('SecurityGroups.member', [*security_group_ids])
+          request({
+            'Action'           => 'ApplySecurityGroupsToLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::ApplySecurityGroupsToLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :apply_security_groups :apply_security_groups_to_load_balancer
+
+      end
+
+      class Mock
+
+        def apply_security_groups_to_load_balancer(security_group_ids, lb_name)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          load_balancer['SecurityGroups'] << security_group_ids
+          load_balancer['SecurityGroups'].flatten!.uniq!
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DetachLoadBalancerFromSubnetsResult' => {
+              'SecurityGroups' => load_balancer['SecurityGroups']
+            }
+          }
+
+          response
+        end
+
+      alias :apply_security_groups :apply_security_groups_to_load_balancer
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/attach_load_balancer_to_subnets.rb

@@ -0,0 +1,61 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/attach_load_balancer_to_subnets'
+
+        # Enable a subnet for an existing ELB
+        #
+        # ==== Parameters
+        # * subnet_ids<~Array> - List of subnet ids to enable on ELB
+        # * lb_name<~String> - Load balancer to enable availability zones on
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'AttachLoadBalancerToSubnetsResult'<~Hash>:
+        #       * 'Subnets'<~Array> - array of strings describing the subnet ids currently enabled
+        def attach_load_balancer_to_subnets(subnet_ids, lb_name)
+          params = Fog::AWS.indexed_param('Subnets.member', [*subnet_ids])
+          request({
+            'Action'           => 'AttachLoadBalancerToSubnets',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::AttachLoadBalancerToSubnets.new
+          }.merge!(params))
+        end
+
+        alias :enable_subnets :attach_load_balancer_to_subnets
+
+      end
+
+      class Mock
+
+        def attach_load_balancer_to_subnets(subnet_ids, lb_name)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          load_balancer['Subnets'] << subnet_ids
+          load_balancer['Subnets'].flatten!.uniq!
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'AttachLoadBalancerToSubnetsResult' => {
+              'Subnets' => load_balancer['Subnets']
+            }
+          }
+
+          response
+        end
+
+        alias :enable_subnets :attach_load_balancer_to_subnets
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/create_app_cookie_stickiness_policy.rb

@@ -37,6 +37,8 @@ module Fog
 
             load_balancer['Policies']['AppCookieStickinessPolicies'] << { 'CookieName' => cookie_name, 'PolicyName' => policy_name }
 
+            create_load_balancer_policy(lb_name, policy_name, 'AppCookieStickinessPolicyType', {'CookieName' => cookie_name})
+
             response.body = {
               'ResponseMetadata' => {
                 'RequestId' => Fog::AWS::Mock.request_id

data/lib/fog/aws/requests/elb/create_lb_cookie_stickiness_policy.rb

@@ -37,7 +37,9 @@ module Fog
             response = Excon::Response.new
             response.status = 200
 
-            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'PolicyName' => policy_name, 'CookieExpirationPeriod' => cookie_expiration_period }
+            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'CookieExpirationPeriod' => cookie_expiration_period, 'PolicyName' => policy_name }
+
+            create_load_balancer_policy(lb_name, policy_name, 'LBCookieStickinessPolicyType', {'CookieExpirationPeriod' => cookie_expiration_period})
 
             response.body = {
               'ResponseMetadata' => {

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -11,9 +11,10 @@ module Fog
         # * availability_zones<~Array> - List of availability zones for the ELB
         # * lb_name<~String> - Name for the new ELB -- must be unique
         # * listeners<~Array> - Array of Hashes describing ELB listeners to assign to the ELB
-        #   * 'Protocol'<~String> - Protocol to use. Either HTTP or TCP.
+        #   * 'Protocol'<~String> - Protocol to use. Either HTTP, HTTPS, TCP or SSL.
         #   * 'LoadBalancerPort'<~Integer> - The port that the ELB will listen to for outside traffic
         #   * 'InstancePort'<~Integer> - The port on the instance that the ELB will forward traffic to
+        #   * 'InstanceProtocol'<~String> - Protocol for sending traffic to an instance. Either HTTP, HTTPS, TCP or SSL.
         #   * 'SSLCertificateId'<~String> - ARN of the server certificate
         # ==== Returns
         # * response<~Excon::Response>:
@@ -22,23 +23,29 @@ module Fog
         #       * 'RequestId'<~String> - Id of request
         #     * 'CreateLoadBalancerResult'<~Hash>:
         #       * 'DNSName'<~String> - DNS name for the newly created ELB
-        def create_load_balancer(availability_zones, lb_name, listeners)
+        def create_load_balancer(availability_zones, lb_name, listeners, options = {})
           params = Fog::AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
+          params.merge!(Fog::AWS.indexed_param('Subnets.member.%d', options[:subnet_ids]))
+          params.merge!(Fog::AWS.serialize_keys('Scheme', options[:scheme]))
+          params.merge!(Fog::AWS.indexed_param('SecurityGroups.member.%d', options[:security_groups])) 
 
           listener_protocol = []
           listener_lb_port = []
           listener_instance_port = []
+          listener_instance_protocol = []
           listener_ssl_certificate_id = []
           listeners.each do |listener|
             listener_protocol.push(listener['Protocol'])
             listener_lb_port.push(listener['LoadBalancerPort'])
             listener_instance_port.push(listener['InstancePort'])
+            listener_instance_protocol.push(listener['InstanceProtocol'])
             listener_ssl_certificate_id.push(listener['SSLCertificateId'])
           end
 
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.Protocol', listener_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.LoadBalancerPort', listener_lb_port))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstancePort', listener_instance_port))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstanceProtocol', listener_instance_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.SSLCertificateId', listener_ssl_certificate_id))
 
           request({
@@ -50,13 +57,13 @@ module Fog
       end
 
       class Mock
-        def create_load_balancer(availability_zones, lb_name, listeners = [])
+        def create_load_balancer(availability_zones, lb_name, listeners = [], options = {})
           response = Excon::Response.new
           response.status = 200
 
           raise Fog::AWS::ELB::IdentifierTaken if self.data[:load_balancers].has_key? lb_name
 
-          certificate_ids = Fog::AWS::IAM.new.list_server_certificates.body['Certificates'].collect { |c| c['Arn'] }
+          certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
 
           listeners = [*listeners].map do |listener|
             if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
@@ -68,6 +75,9 @@ module Fog
           dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
           self.data[:load_balancers][lb_name] = {
             'AvailabilityZones' => availability_zones,
+            'Subnets' => options[:subnet_ids],
+            'Scheme' => options[:scheme].nil? ? 'internet-facing' : options[:scheme],
+            'SecurityGroups' => options[:security_groups],
             'CanonicalHostedZoneName' => '',
             'CanonicalHostedZoneNameID' => '',
             'CreatedTime' => Time.now,
@@ -83,15 +93,15 @@ module Fog
             'ListenerDescriptions' => listeners,
             'LoadBalancerName' => lb_name,
             'Policies' => {
+              'AppCookieStickinessPolicies' => [],
               'LBCookieStickinessPolicies' => [],
-              'AppCookieStickinessPolicies' => []
+              'Proper' => []
             },
             'SourceSecurityGroup' => {
               'GroupName' => '',
               'OwnerAlias' => ''
             }
           }
-
           response.body = {
             'ResponseMetadata' => {
               'RequestId' => Fog::AWS::Mock.request_id

data/lib/fog/aws/requests/elb/create_load_balancer_listeners.rb

@@ -10,9 +10,10 @@ module Fog
         # ==== Parameters
         # * lb_name<~String> - Name for the new ELB -- must be unique
         # * listeners<~Array> - Array of Hashes describing ELB listeners to add to the ELB
-        #   * 'Protocol'<~String> - Protocol to use. Either HTTP or TCP.
+        #   * 'Protocol'<~String> - Protocol to use. Either HTTP, HTTPS, TCP or SSL.
         #   * 'LoadBalancerPort'<~Integer> - The port that the ELB will listen to for outside traffic
         #   * 'InstancePort'<~Integer> - The port on the instance that the ELB will forward traffic to
+        #   * 'InstanceProtocol'<~String> - Protocol for sending traffic to an instance. Either HTTP, HTTPS, TCP or SSL.
         #   * 'SSLCertificateId'<~String> - ARN of the server certificate
         # ==== Returns
         # * response<~Excon::Response>:
@@ -25,17 +26,20 @@ module Fog
           listener_protocol = []
           listener_lb_port = []
           listener_instance_port = []
+          listener_instance_protocol = []
           listener_ssl_certificate_id = []
           listeners.each do |listener|
             listener_protocol.push(listener['Protocol'])
             listener_lb_port.push(listener['LoadBalancerPort'])
             listener_instance_port.push(listener['InstancePort'])
+            listener_instance_protocol.push(listener['InstanceProtocol'])
             listener_ssl_certificate_id.push(listener['SSLCertificateId'])
           end
 
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.Protocol', listener_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.LoadBalancerPort', listener_lb_port))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstancePort', listener_instance_port))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstanceProtocol', listener_instance_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.SSLCertificateId', listener_ssl_certificate_id))
 
           request({
@@ -52,12 +56,17 @@ module Fog
           if load_balancer = self.data[:load_balancers][lb_name]
             response = Excon::Response.new
 
-            certificate_ids = Fog::AWS::IAM.new.list_server_certificates.body['Certificates'].collect { |c| c['Arn'] }
+            certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
 
             listeners.each do |listener|
               if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
                 raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
               end
+
+              if (%w( HTTP HTTPS).include?(listener['Protocol']) && !%w( HTTP HTTPS ).include?(listener['InstanceProtocol'])) ||
+                  (%w( TCP SSL).include?(listener['Protocol']) && !%w( TCP SSL ).include?(listener['InstanceProtocol']))
+                raise Fog::AWS::ELB::ValidationError
+              end if listener['Protocol'] && listener['InstanceProtocol']
               load_balancer['ListenerDescriptions'] << {'Listener' => listener, 'PolicyNames' => []}
             end
 

data/lib/fog/aws/requests/elb/create_load_balancer_policy.rb

@@ -0,0 +1,79 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/empty'
+
+        # Create Elastic Load Balancer Policy
+        #
+        # ==== Parameters
+        # * lb_name<~String> - The name associated with the LoadBalancer for which the policy is being created. This name must be unique within the client AWS account.
+        # * attributes<~Hash> - A list of attributes associated with the policy being created.
+        #   * 'AttributeName'<~String> - The name of the attribute associated with the policy.
+        #   * 'AttributeValue'<~String> - The value of the attribute associated with the policy.
+        # * name<~String> - The name of the LoadBalancer policy being created. The name must be unique within the set of policies for this LoadBalancer.
+        # * type_name<~String> - The name of the base policy type being used to create this policy. To get the list of policy types, use the DescribeLoadBalancerPolicyTypes action.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
+          params = {}
+
+          attribute_name = []
+          attribute_value = []
+          attributes.each do |name, value|
+            attribute_name.push(name)
+            attribute_value.push(value)
+          end
+
+          params.merge!(Fog::AWS.indexed_param('PolicyAttributes.member.%d.AttributeName', attribute_name))
+          params.merge!(Fog::AWS.indexed_param('PolicyAttributes.member.%d.AttributeValue', attribute_value))
+
+          request({
+            'Action'           => 'CreateLoadBalancerPolicy',
+            'LoadBalancerName' => lb_name,
+            'PolicyName'       => name,
+            'PolicyTypeName'   => type_name,
+            :parser            => Fog::Parsers::AWS::ELB::Empty.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+        def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
+          if load_balancer = self.data[:load_balancers][lb_name]
+            raise Fog::AWS::IAM::DuplicatePolicyName if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
+            raise Fog::AWS::IAM::PolicyTypeNotFound unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
+
+            response = Excon::Response.new
+
+            attributes = attributes.map do |key, value|
+              {"AttributeName" => key, "AttributeValue" => value.to_s}
+            end
+
+            load_balancer['Policies']['Proper'] << {
+              'PolicyAttributeDescriptions' => attributes,
+              'PolicyName' => name,
+              'PolicyTypeName' => type_name
+            }
+
+            response.status = 200
+            response.body = {
+              'ResponseMetadata' => {
+                'RequestId' => Fog::AWS::Mock.request_id
+              }
+            }
+
+            response
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/delete_load_balancer_policy.rb

@@ -34,7 +34,7 @@ module Fog
             response.status = 200
 
             load_balancer['Policies'].each do |name, policies|
-              policies.delete_if { |p| p['PolicyName'] == policy_name }
+              policies.delete_if { |policy| policy['PolicyName'] == policy_name }
             end
 
             response.body = {

data/lib/fog/aws/requests/elb/deregister_instances_from_load_balancer.rb

@@ -37,7 +37,7 @@ module Fog
           raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
           instance_ids = [*instance_ids]
           instance_ids.each do |instance|
-            raise Fog::AWS::ELB::InvalidInstance unless Compute[:aws].servers.get(instance)
+            raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
           end
 
           response = Excon::Response.new