fog 0.7.2 → 0.8.0

data/lib/fog/terremark/parsers/shared/get_vdc.rb

@@ -90,15 +90,15 @@ module Fog
             case name
             when 'Allocated', 'Limit', 'Units', 'Used'
               if @in_cpu
-                @response['ComputeCapacity']['Cpu'][name] = @value
+                @response['ComputeCapacity']['Cpu'][name] = value
               elsif @in_deployed_vms_quota
-                @response['ComputeCapacity']['DeployedVmsQuota'][name] = @value
+                @response['ComputeCapacity']['DeployedVmsQuota'][name] = value
               elsif @in_instantiated_vms_quota
-                @response['ComputeCapacity']['InstantiatedVmsQuota'][name] = @value
+                @response['ComputeCapacity']['InstantiatedVmsQuota'][name] = value
               elsif @in_memory
-                @response['ComputeCapacity']['Memory'][name] = @value
+                @response['ComputeCapacity']['Memory'][name] = value
               elsif @in_storage_capacity
-                @response['StorageCapacity'][name] = @value
+                @response['StorageCapacity'][name] = value
               end
             when 'Cpu'
               @in_cpu = false
@@ -111,7 +111,7 @@ module Fog
             when 'StorageCapacity'
               @in_storage_capacity = false
             when 'Type'
-              @response[name] = @value
+              @response[name] = value
             end
           end
 

data/lib/fog/terremark/parsers/shared/internet_service.rb

@@ -31,27 +31,27 @@ module Fog
           def end_element(name)
             case name
             when 'Description', 'Protocol'
-              @response[name] = @value
+              @response[name] = value
             when 'Enabled'
-              if @value == 'false'
+              if value == 'false'
                 @response[name] = false
               else
                 @response[name] = true
               end
             when 'Id'
               if @in_public_ip_address
-                @response['PublicIpAddress'][name] = @value.to_i
+                @response['PublicIpAddress'][name] = value.to_i
               else
-                @response[name] = @value.to_i
+                @response[name] = value.to_i
               end
             when 'Name'
               if @in_public_ip_address
-                @response['PublicIpAddress'][name] = @value
+                @response['PublicIpAddress'][name] = value
               else
-                @response[name] = @value
+                @response[name] = value
               end
             when 'Port', 'Timeout'
-              @response[name] = @value.to_i
+              @response[name] = value.to_i
             when 'PublicIpAddress'
               @in_public_ip_address = false
             end

data/lib/fog/terremark/parsers/shared/network.rb

@@ -39,7 +39,7 @@ module Fog
           def end_element(name)
             case name
             when "Gateway", "Netmask", "FenceMode"
-              @response[name.downcase] = @value
+              @response[name.downcase] = value
             end
           end
 

data/lib/fog/terremark/parsers/shared/node_service.rb

@@ -12,15 +12,15 @@ module Fog
           def end_element(name)
             case name
             when 'Description', 'Href', 'IpAddress', 'Name', 'Protocol'
-              @response[name] = @value
+              @response[name] = value
             when 'Enabled'
-              if @value == 'false'
+              if value == 'false'
                 @response[name] = false
               else
                 @response[name] = true
               end
             when 'Id', 'Port'
-              @response[name] = @value.to_i
+              @response[name] = value.to_i
             end
           end
 

data/lib/fog/terremark/parsers/shared/public_ip.rb

@@ -12,9 +12,9 @@ module Fog
           def end_element(name)
             case name
             when 'Href', 'Name'
-              @response[name.downcase] = @value
+              @response[name.downcase] = value
             when 'Id'
-              @response['id'] = @value.to_i
+              @response['id'] = value.to_i
             end
           end
 

data/lib/fog/terremark/parsers/shared/vapp.rb

@@ -39,15 +39,15 @@ module Fog
           def end_element(name)
             case name
             when 'IpAddress'
-              @response['IpAddress'] = @value
+              @response['IpAddress'] = value
             when 'Description'
               if @in_operating_system
-                @response['OperatingSystem'][name] = @value
+                @response['OperatingSystem'][name] = value
                 @in_operating_system = false
               end
             when 'ResourceType'
-              @resource_type = @value
-              case @value
+              @resource_type = value
+              case value
               when '3'
                 @get_cpu = true # cpu
               when '4'  # memory
@@ -58,12 +58,12 @@ module Fog
             when 'VirtualQuantity'
               case @resource_type
               when '3'
-                @response['VirtualHardware']['cpu'] = @value
+                @response['VirtualHardware']['cpu'] = value
               when '4'
-                @response['VirtualHardware']['ram'] = @value
+                @response['VirtualHardware']['ram'] = value
               when '17'
                 @response['VirtualHardware']['disks'] ||= []
-                @response['VirtualHardware']['disks'] << @value
+                @response['VirtualHardware']['disks'] << value
               end
             end
           end

data/spec/ecloud/spec_helper.rb

@@ -313,7 +313,7 @@ Spec::Matchers.define :have_key_with_array do |expected_key, expected_array|
   end
   failure_message_for_should do |actual|
     "Items not found in array:\n#{expected_array.select { |expected_item| !actual[expected_key].include?(expected_item) }.map { |item| item.inspect }.join("\n")}\n"  +
-    "Orignal items:\n#{actual[expected_key].map { |item| item.inspect }.join("\n") }\n"+
+    "Original items:\n#{actual[expected_key].map { |item| item.inspect }.join("\n") }\n"+
     "Length Difference: #{expected_array.length - actual[expected_key].length}"
   end
 end

data/tests/aws/requests/cloud_formation/stack_tests.rb

@@ -113,6 +113,8 @@ Shindo.tests('AWS::CloudFormation | stack requests', ['aws', 'cloudformation'])
       AWS[:cloud_formation].describe_stacks.body
     end
 
+    sleep(1) # avoid throttling
+
     tests("describe_stack_events('#{@stack_name}')").formats(@describe_stack_events_format) do
       pending if Fog.mocking?
       AWS[:cloud_formation].describe_stack_events(@stack_name).body

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

@@ -0,0 +1,44 @@
+class AWS
+  module ELB
+    module Formats
+
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      LOAD_BALANCER = {
+        "CreatedTime" => Time,
+        "ListenerDescriptions" => Array,
+        "HealthCheck" => {"HealthyThreshold" => Integer, "Timeout" => Integer, "UnhealthyThreshold" => Integer, "Interval" => Integer, "Target" => String},
+        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array},
+        "AvailabilityZones" => Array,
+        "DNSName" => String,
+        "LoadBalancerName"=> String,
+        "Instances"=> Array
+      }
+
+      CREATE_LOAD_BALANCER = BASIC.merge({
+        'CreateLoadBalancerResult' => { 'DNSName' => String }
+      })
+
+      DESCRIBE_LOAD_BALANCERS = BASIC.merge({
+        'DescribeLoadBalancersResult' => {'LoadBalancerDescriptions' => [LOAD_BALANCER]}
+      })
+
+      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/aws/requests/elb/load_balancer_tests.rb

@@ -0,0 +1,82 @@
+Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-elb'
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    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
+    end
+
+    tests("#describe_load_balancers").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCERS) do
+      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') }
+    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
+      }
+
+      AWS[:elb].configure_health_check(@load_balancer_id, health_check).body
+    end
+
+    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
+    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
+    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
+    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
+    end
+
+    tests("#create_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
+      listeners = [
+        {'Protocol' => 'tcp', 'LoadBalancerPort' => 443, 'InstancePort' => 443},
+        {'Protocol' => 'HTTP', 'LoadBalancerPort' => 80, 'InstancePort' => 80}
+      ]
+      AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+    end
+
+    tests("#set_load_balancer_policies_of_listener adds policy").formats(AWS::ELB::Formats::BASIC) do
+      port, policies = 80, ['fog-lb-expiry']
+      body = 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
+      body = AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, []).body
+    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
+    end
+
+    tests("#delete_load_balancer").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+      AWS[:elb].delete_load_balancer(@load_balancer_id).body
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
+
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests('load_balancers') do
+      tests('getting a missing elb') do
+        returns(nil) { AWS[:elb].load_balancers.get('no-such-elb') }
+      end
+    end
+
+    elb = nil
+    elb_id = 'fog-test'
+
+    tests('create') do
+      elb = AWS[:elb].load_balancers.create(:id => elb_id)
+      tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
+      tests("created_at is set").returns(true) { (Time.now-10..Time.now).include? elb.created_at }
+      tests("policies is empty").returns([]) { elb.policies }
+    end
+
+    tests('all') do
+      elb_ids = AWS[:elb].load_balancers.all.map{|e| e.id}
+      tests("contains elb").returns(true) { elb_ids.include? elb_id }
+    end
+
+    tests('get') do
+      elb2 = AWS[:elb].load_balancers.get(elb_id)
+      tests('ids match').returns(elb_id) { elb2.id }
+    end
+
+    tests('createing a duplicate elb') do
+      raises(Fog::AWS::ELB::IdentifierTaken) do
+        AWS[:elb].load_balancers.create(:id => elb_id, :availability_zones => ['us-east-1d'])
+      end
+    end
+
+    tests('registering an invalid instance') do
+      raises(Fog::AWS::ELB::InvalidInstance) { elb.register_instances('i-00000000') }
+    end
+
+    tests('deregistering an invalid instance') do
+      raises(Fog::AWS::ELB::InvalidInstance) { elb.deregister_instances('i-00000000') }
+    end
+
+    server = AWS[:compute].servers.create
+    tests('register instance') do
+      begin
+        elb.register_instances(server.id)
+      rescue Fog::AWS::ELB::InvalidInstance
+        # It may take a moment for a newly created instances to be visible to ELB requests
+        raise if @retried_registered_instance
+        @retried_registered_instance = true
+        sleep 1
+        retry
+      end
+
+      returns([server.id]) { elb.instances }
+    end
+
+    tests('instance_health') do
+      returns('OutOfService') do
+        elb.instance_health.detect{|hash| hash['InstanceId'] == server.id}['State']
+      end
+
+      returns([server.id]) { elb.instances_out_of_service }
+    end
+
+    tests('deregister instance') do
+      elb.deregister_instances(server.id)
+      returns([]) { elb.instances }
+    end
+    server.destroy
+
+    tests('disable_availability_zones') do
+      elb.disable_availability_zones(%w{us-east-1c us-east-1d})
+      returns(%w{us-east-1a us-east-1b}) { elb.availability_zones.sort }
+    end
+
+    tests('enable_availability_zones') do
+      elb.enable_availability_zones(%w{us-east-1c us-east-1d})
+      returns(%w{us-east-1a us-east-1b us-east-1c us-east-1d}) { elb.availability_zones.sort }
+    end
+
+    tests('default health check') do
+      default_health_check = {
+        "HealthyThreshold"=>10,
+        "Timeout"=>5,
+        "UnhealthyThreshold"=>2,
+        "Interval"=>30,
+        "Target"=>"TCP:80"
+      }
+      returns(default_health_check) { elb.health_check }
+    end
+
+    tests('configure_health_check') do
+      new_health_check = {
+        "HealthyThreshold"=>5,
+        "Timeout"=>10,
+        "UnhealthyThreshold"=>3,
+        "Interval"=>15,
+        "Target"=>"HTTP:80/index.html"
+      }
+      elb.configure_health_check(new_health_check)
+      returns(new_health_check) { elb.health_check }
+    end
+
+    tests('listeners') do
+      default_listener_description = [{"Listener"=>{"InstancePort"=>80, "Protocol"=>"HTTP", "LoadBalancerPort"=>80}, "PolicyNames"=>[]}]
+      tests('default') do
+        returns(1) { elb.listeners.size }
+
+        listener = elb.listeners.first
+        returns([80,80,'HTTP', []]) { [listener.instance_port, listener.lb_port, listener.protocol, listener.policy_names] }
+
+      end
+
+      tests('#get') do
+        returns(80) { elb.listeners.get(80).lb_port }
+      end
+
+      tests('create') do
+        new_listener = { 'InstancePort' => 443, 'LoadBalancerPort' => 443, 'Protocol' => 'TCP'}
+        elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'TCP')
+        returns(2) { elb.listeners.size }
+        returns(443) { elb.listeners.get(443).lb_port }
+      end
+
+      tests('destroy') do
+        elb.listeners.get(443).destroy
+        returns(nil) { elb.listeners.get(443) }
+      end
+    end
+
+    tests('policies') do
+      app_policy_id = 'my-app-policy'
+
+      tests 'are empty' do
+        returns([]) { elb.policies.to_a }
+      end
+
+      tests('#all') do
+        returns([]) { elb.policies.all.to_a }
+      end
+
+      tests('create app policy') do
+        elb.policies.create(:id => app_policy_id, :cookie => 'my-app-cookie', :cookie_stickiness => :app)
+        returns(app_policy_id) { elb.policies.first.id }
+      end
+
+      tests('get policy') do
+        returns(app_policy_id) { elb.policies.get(app_policy_id).id }
+      end
+
+      tests('destroy app policy') do
+        elb.policies.first.destroy
+        returns([]) { elb.policies.to_a }
+      end
+
+      lb_policy_id = 'my-lb-policy'
+      tests('create lb policy') do
+        elb.policies.create(:id => lb_policy_id, :expiration => 600, :cookie_stickiness => :lb)
+        returns(lb_policy_id) { elb.policies.first.id }
+      end
+
+      tests('setting a listener policy') do
+        elb.set_listener_policy(80, lb_policy_id)
+        returns([lb_policy_id]) { elb.listeners.get(80).policy_names }
+      end
+
+      tests('unsetting a listener policy') do
+        elb.unset_listener_policy(80)
+        returns([]) { elb.listeners.get(80).policy_names }
+      end
+
+      tests('a malformed policy') do
+        raises(ArgumentError) { elb.policies.create(:id => 'foo', :cookie_stickiness => 'invalid stickiness') }
+      end
+    end
+
+    tests('destroy') do
+      elb.destroy
+    end
+  end
+
+end