fog 0.9.0 → 0.10.0

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

@@ -28,6 +28,27 @@ module Fog
         end
 
       end
+
+      class Mock
+        def create_app_cookie_stickiness_policy(lb_name, policy_name, cookie_name)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            load_balancer['Policies']['AppCookieStickinessPolicies'] << { 'CookieName' => cookie_name, 'PolicyName' => policy_name }
+
+            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/create_lb_cookie_stickiness_policy.rb

@@ -30,6 +30,27 @@ module Fog
         end
 
       end
+
+      class Mock
+        def create_lb_cookie_stickiness_policy(lb_name, policy_name, cookie_expiration_period=nil)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'PolicyName' => policy_name, 'CookieExpirationPeriod' => cookie_expiration_period }
+
+            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/create_load_balancer.rb

@@ -47,7 +47,62 @@ module Fog
             :parser            => Fog::Parsers::AWS::ELB::CreateLoadBalancer.new
           }.merge!(params))
         end
+      end
+
+      class Mock
+        def create_load_balancer(availability_zones, lb_name, listeners = [])
+          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'] }
+
+          listeners = [*listeners].map do |listener|
+            if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
+              raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
+            end
+            {'Listener' => listener, 'PolicyNames' => []}
+          end
+
+          dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
+          self.data[:load_balancers][lb_name] = {
+            'AvailabilityZones' => availability_zones,
+            'CanonicalHostedZoneName' => '',
+            'CanonicalHostedZoneNameID' => '',
+            'CreatedTime' => Time.now,
+            'DNSName' => dns_name,
+            'HealthCheck' => {
+              'HealthyThreshold' => 10,
+              'Timeout' => 5,
+              'UnhealthyThreshold' => 2,
+              'Interval' => 30,
+              'Target' => 'TCP:80'
+            },
+            'Instances' => [],
+            'ListenerDescriptions' => listeners,
+            'LoadBalancerName' => lb_name,
+            'Policies' => {
+              'LBCookieStickinessPolicies' => [],
+              'AppCookieStickinessPolicies' => []
+            },
+            'SourceSecurityGroup' => {
+              'GroupName' => '',
+              'OwnerAlias' => ''
+            }
+          }
 
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'CreateLoadBalancerResult' => {
+              'DNSName' => dns_name
+            }
+          }
+
+          response
+        end
       end
     end
   end

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

@@ -46,6 +46,34 @@ module Fog
         end
 
       end
+
+      class Mock
+        def create_load_balancer_listeners(lb_name, listeners)
+          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'] }
+
+            listeners.each do |listener|
+              if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
+                raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
+              end
+              load_balancer['ListenerDescriptions'] << {'Listener' => listener, 'PolicyNames' => []}
+            end
+
+            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.rb

@@ -28,6 +28,24 @@ module Fog
         end
 
       end
+
+      class Mock
+        def delete_load_balancer(lb_name)
+          response = Excon::Response.new
+          response.status = 200
+
+          self.data[:load_balancers].delete(lb_name)
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DeleteLoadBalancerResult' => nil
+          }
+
+          response
+        end
+      end
     end
   end
 end

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

@@ -16,7 +16,7 @@ module Fog
         #     * 'ResponseMetadata'<~Hash>:
         #       * 'RequestId'<~String> - Id of request
         def delete_load_balancer_listeners(lb_name, load_balancer_ports)
-          params = Fog::AWS.indexed_param('LoadBalancerPorts.memeber.%d', load_balancer_ports)
+          params = Fog::AWS.indexed_param('LoadBalancerPorts.member.%d', load_balancer_ports)
 
           request({
             'Action'           => 'DeleteLoadBalancerListeners',
@@ -26,6 +26,25 @@ module Fog
         end
 
       end
+
+      class Mock
+        def delete_load_balancer_listeners(lb_name, load_balancer_ports)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          load_balancer['ListenerDescriptions'].delete_if { |listener| load_balancer_ports.include? listener['Listener']['LoadBalancerPort'] }
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+
+          response
+        end
+      end
     end
   end
 end

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

@@ -26,6 +26,29 @@ module Fog
         end
 
       end
+
+      class Mock
+        def delete_load_balancer_policy(lb_name, policy_name)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            load_balancer['Policies'].each do |name, policies|
+              policies.delete_if { |p| p['PolicyName'] == policy_name }
+            end
+
+            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/deregister_instances_from_load_balancer.rb

@@ -33,15 +33,31 @@ module Fog
       end
 
       class Mock
-
         def deregister_instances_from_load_balancer(instance_ids, lb_name)
-          Fog::Mock.not_implemented
+          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)
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          load_balancer['Instances'].delete_if { |i| instance_ids.include? i['InstanceId'] }
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DeregisterInstancesFromLoadBalancerResult' => {
+              'Instances' => load_balancer['Instances'].dup
+            }
+          }
+
+          response
         end
-
         alias :deregister_instances :deregister_instances_from_load_balancer
-
       end
-
     end
   end
 end

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

@@ -32,6 +32,41 @@ module Fog
         end
 
       end
+
+      class Mock
+        def describe_instance_health(lb_name, instance_ids = [])
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          instance_ids = [*instance_ids]
+          instance_ids = load_balancer['Instances'].collect { |i| i['InstanceId'] } unless instance_ids.any?
+          data = instance_ids.map do |id|
+            unless instance = Compute[:aws].servers.get(id)
+              raise Fog::AWS::ELB::InvalidInstance
+            end
+
+            {
+              'Description' => "",
+              'InstanceId' => instance.id,
+              'ReasonCode' => "",
+              'State' => 'OutOfService'
+            }
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeInstanceHealthResult' => {
+              'InstanceStates' => data
+            }
+          }
+
+          response
+        end
+      end
     end
   end
 end

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

@@ -51,6 +51,35 @@ module Fog
         end
 
       end
+
+      class Mock
+        def describe_load_balancers(lb_names = [])
+          lb_names = [*lb_names]
+          load_balancers = if lb_names.any?
+            lb_names.map do |lb_name|
+              lb = self.data[:load_balancers].find { |name, data| name == lb_name }
+              raise Fog::AWS::ELB::NotFound unless lb
+              lb[1]
+            end.compact
+          else
+            self.data[:load_balancers].values
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancersResult' => {
+              'LoadBalancerDescriptions' => load_balancers
+            }
+          }
+
+          response
+        end
+      end
     end
   end
 end

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

@@ -17,7 +17,7 @@ module Fog
         #     * 'ResponseMetadata'<~Hash>:
         #       * 'RequestId'<~String> - Id of request
         #     * 'DisableAvailabilityZonesForLoadBalancerResult'<~Hash>:
-        #       * 'AvailabilityZones'<~Array> - array of strings describing instances currently enabled
+        #       * 'AvailabilityZones'<~Array> - A list of updated Availability Zones for the LoadBalancer.
         def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
           params = Fog::AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
           request({
@@ -32,15 +32,28 @@ module Fog
       end
 
       class Mock
-
         def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
-          Fog::Mock.not_implemented
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          load_balancer['AvailabilityZones'].delete_if { |az| availability_zones.include? az }
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DisableAvailabilityZonesForLoadBalancerResult' => {
+              'AvailabilityZones' => load_balancer['AvailabilityZones']
+            }
+          }
+
+          response
         end
 
         alias :disable_zones :disable_availability_zones_for_load_balancer
-
       end
-
     end
   end
 end

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

@@ -34,13 +34,28 @@ module Fog
       class Mock
 
         def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
-          Fog::Mock.not_implemented
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          load_balancer['AvailabilityZones'] << availability_zones
+          load_balancer['AvailabilityZones'].flatten!.uniq!
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'EnableAvailabilityZonesForLoadBalancerResult' => {
+              'AvailabilityZones' => load_balancer['AvailabilityZones']
+            }
+          }
+
+          response
         end
 
         alias :enable_zones :enable_availability_zones_for_load_balancer
-
       end
-
     end
   end
 end

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

@@ -33,15 +33,32 @@ module Fog
       end
 
       class Mock
-
         def register_instances_with_load_balancer(instance_ids, lb_name)
-          Fog::Mock.not_implemented
-        end
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+          instance_ids = [*instance_ids]
+          instances = instance_ids.map do |instance|
+            raise Fog::AWS::ELB::InvalidInstance unless Compute[:aws].servers.get(instance)
+            {'InstanceId' => instance}
+          end
 
-        alias :register_instances :register_instances_with_load_balancer
+          response = Excon::Response.new
+          response.status = 200
 
-      end
+          load_balancer['Instances'] = instances.dup
 
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'RegisterInstancesWithLoadBalancerResult' => {
+              'Instances' => instances
+            }
+          }
+
+          response
+        end
+        alias :register_instances :register_instances_with_load_balancer
+      end
     end
   end
 end