fog 0.9.0 → 0.10.0

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

@@ -0,0 +1,235 @@
+Shindo.tests('AWS::AutoScaling | model_tests', ['aws', 'auto_scaling']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    lc = nil
+    lc_id = 'fog-model-lc'
+
+    tests('configurations') do
+      tests('getting a missing configuration') do
+        returns(nil) { AWS[:auto_scaling].configurations.get('fog-no-such-lc') }
+      end
+
+      tests('create configuration') do
+        lc = AWS[:auto_scaling].configurations.create(:id => lc_id, :image_id => 'ami-8c1fece5', :instance_type => 't1.micro')
+        #tests("dns names is set").returns(true) { lc.dns_name.is_a?(String) }
+        tests("created_at is set").returns(true) { Time === lc.created_at }
+        #tests("policies is empty").returns([]) { lc.policies }
+      end
+
+      tests('all configurations') do
+        lc_ids = AWS[:auto_scaling].configurations.all.map{|e| e.id}
+        tests("contains lc").returns(true) { lc_ids.include? lc_id }
+      end
+
+      tests('get configuration') do
+        lc2 = AWS[:auto_scaling].configurations.get(lc_id)
+        tests('ids match').returns(lc_id) { lc2.id }
+      end
+
+      tests('creating a duplicate configuration') do
+        raises(Fog::AWS::AutoScaling::IdentifierTaken) do
+          AWS[:auto_scaling].configurations.create(:id => lc_id, :image_id => 'ami-8c1fece5', :instance_type => 't1.micro')
+        end
+      end
+    end
+
+    tests('groups') do
+      tests('getting a missing group') do
+        returns(nil) { AWS[:auto_scaling].groups.get('fog-no-such-asg') }
+      end
+
+      asg = nil
+      asg_id = 'fog-model-asg'
+
+      tests('create') do
+        asg = AWS[:auto_scaling].groups.create(:id => asg_id, :availability_zones => ['us-east-1d'], :launch_configuration_name => lc_id)
+        #tests("dns names is set").returns(true) { asg.dns_name.is_a?(String) }
+        tests("created_at is set").returns(true) { Time === asg.created_at }
+        #tests("policies is empty").returns([]) { asg.policies }
+      end
+
+      tests('all') do
+        asg_ids = AWS[:auto_scaling].groups.all.map{|e| e.id}
+        tests("contains asg").returns(true) { asg_ids.include? asg_id }
+      end
+
+      tests('get') do
+        asg2 = AWS[:auto_scaling].groups.get(asg_id)
+        tests('ids match').returns(asg_id) { asg2.id }
+      end
+
+      tests('suspend processes') do
+        asg.suspend_processes()
+        #tests('processes suspended').returns([]) { asg.suspended_processes }
+      end
+
+      tests('resume processes') do
+        asg.resume_processes()
+        tests('no processes suspended').returns([]) { asg.suspended_processes }
+      end
+
+      tests('creating a duplicate group') do
+        raises(Fog::AWS::AutoScaling::IdentifierTaken) do
+          AWS[:auto_scaling].groups.create(:id => asg_id, :availability_zones => ['us-east-1d'], :launch_configuration_name => lc_id)
+        end
+      end
+
+      tests('destroy group') do
+        asg.destroy
+        asg = nil
+      end
+
+      #tests('registering an invalid instance') do
+      #  raises(Fog::AWS::AutoScaling::InvalidInstance) { asg.register_instances('i-00000000') }
+      #end
+
+      #tests('deregistering an invalid instance') do
+      #  raises(Fog::AWS::AutoScaling::InvalidInstance) { asg.deregister_instances('i-00000000') }
+      #end
+    end
+
+    tests('configurations') do
+      tests('destroy configuration') do
+        lc.destroy
+        lc = nil
+      end
+    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
+  end
+end

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

@@ -85,7 +85,7 @@ Shindo.tests('AWS::CloudFormation | stack requests', ['aws', 'cloudformation'])
 
     unless Fog.mocking?
       @stack_name = 'fogstack' << Time.now.to_i.to_s
-      @keypair = Compute[:aws].key_pairs.create(:name => 'cloudformation')
+      @keypair = Fog::Compute[:aws].key_pairs.create(:name => 'cloudformation')
       @template_url = 'https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2InstanceSample-1.0.0.template'
     end
 

data/tests/aws/requests/cloud_watch/get_metric_statistics_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('AWS::CloudWatch | metric requests', ['aws', 'cloudwatch']) do
+  tests('success') do
+
+    @metrics_statistic_format = {
+      'GetMetricStatisticsResult' => {
+        'Label' => String,
+        'Datapoints' => [{
+          "Timestamp" => Time,
+          'Unit' => String,
+          'Minimum' => Float,
+          'Maximum' => Float,
+          'Average' => Float,
+          'Sum' => Float,
+          'SampleCount' => Float
+        }],    
+      },
+      'ResponseMetadata' => {
+        'RequestId' => String
+      }
+    }
+
+    tests("#get_metric_statistics").formats(@metrics_statistic_format) do
+      pending if Fog.mocking?
+      instanceId = 'i-420c352f'
+      AWS[:cloud_watch].get_metric_statistics({'Statistics' => ['Minimum','Maximum','Sum','SampleCount','Average'], 'StartTime' => (Time.now-600).iso8601, 'EndTime' => Time.now.iso8601, 'Period' => 60, 'MetricName' => 'DiskReadBytes', 'Namespace' => 'AWS/EC2', 'Dimensions' => [{'Name' => 'InstanceId', 'Value' => instanceId}]}).body
+    end
+  end
+end

data/tests/aws/requests/cloud_watch/list_metrics_test.rb

@@ -0,0 +1,64 @@
+Shindo.tests('AWS::CloudWatch | metric requests', ['aws', 'cloudwatch']) do
+
+  tests('success') do
+    @metrics_list_format = {
+      'ListMetricsResult' => {
+        'Metrics' => 
+          [{
+            'Dimensions' => 
+            [{
+              'Name' => String,
+              'Value' => String
+            }],
+            "MetricName" => String,
+            "Namespace" => String
+          }],
+        'NextToken' => Fog::Nullable::String,
+      },
+      'ResponseMetadata' => {"RequestId"=> String},
+    }
+    @instanceId = 'i-2f3eab59'
+    @dimension_filtered_metrics_list_format = {
+      'ListMetricsResult' => {
+        'Metrics' => 
+          [{
+            'Dimensions' => 
+            [{
+              'Name' => 'InstanceId',
+              'Value' => @instanceId
+            }],
+            "MetricName" => String,
+            "Namespace" => String
+          }],
+        'NextToken' => Fog::Nullable::String,
+      },
+      'ResponseMetadata' => {"RequestId"=> String},
+    }
+
+    tests("#list_metrics").formats(@metrics_list_format) do
+      pending if Fog.mocking?
+      AWS[:cloud_watch].list_metrics.body
+    end
+
+    tests("#dimension_filtered_list_metrics").formats(@dimension_filtered_metrics_list_format) do
+      pending if Fog.mocking?
+      AWS[:cloud_watch].list_metrics('Dimensions' => [{'Name' => 'InstanceId', 'Value' => @instanceId}]).body
+    end
+
+    tests("#metric_name_filtered_list_metrics").returns(true) do
+      pending if Fog.mocking?
+      metricName = "CPUUtilization"
+      AWS[:cloud_watch].list_metrics('MetricName' => metricName).body['ListMetricsResult']['Metrics'].all? do |metric|
+        metric['MetricName'] == metricName
+      end
+    end
+
+    tests("#namespace_filtered_list_metrics").returns(true) do
+      pending if Fog.mocking?
+      namespace = "AWS/EC2"
+      AWS[:cloud_watch].list_metrics('Namespace' => namespace).body['ListMetricsResult']['Metrics'].all? do |metric|
+        metric['Namespace'] == namespace
+      end
+    end
+  end
+end

data/tests/aws/requests/cloud_watch/put_metric_data_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests('AWS::CloudWatch | metric requests', ['aws', 'cloudwatch']) do
+  tests('success') do
+
+    namespace = 'Custom/Test'
+    @puts_format = {'ResponseMetadata' => {'RequestId' => String}}
+
+    tests('#puts_value').formats(@puts_format) do
+      pending if Fog.mocking?
+      AWS[:cloud_watch].put_metric_data(namespace, [{'MetricName' => 'RequestTest', 'Unit' => 'None', 'Value' => 1}]).body
+    end
+
+    tests('#puts_statistics_set').succeeds do
+      pending if Fog.mocking?
+      AWS[:cloud_watch].put_metric_data(namespace, [{'MetricName' => 'RequestTest', 'Unit' => 'None', 'StatisticValues' => {'Minimum' => 0, 'Maximum' => 9, 'Sum' => 45, 'SampleCount' => 10, 'Average' => 4.5}}]).body
+    end
+
+    tests('#puts with dimensions').succeeds do
+      pending if Fog.mocking?
+      dimensions = [{}]
+      AWS[:cloud_watch].put_metric_data(namespace, [{'MetricName' => 'RequestTest', 'Unit' => 'None', 'Value' => 1, 'Dimensions' => dimensions}]).body
+    end
+
+    tests('#puts more than one').succeeds do
+      pending if Fog.mocking?
+      datapoints = (0...3).collect do |i|
+        dp = {'MetricName' => "#{i}RequestTest", 'Unit' => 'None', 'Value' => i}
+        if i%2==0
+          dp['Dimensions'] = [{'Name' => 'Ruler', 'Value' => "measurement_#{i}"}]
+        end
+        dp
+      end
+      AWS[:cloud_watch].put_metric_data(namespace, datapoints).body
+    end
+
+  end
+end

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

@@ -0,0 +1,50 @@
+Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-listener'
+  @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']
+
+    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
+    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("#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) }
+    end
+
+    tests("#create_load_balancer_listeners with invalid SSL certificate").raises(Fog::AWS::IAM::NotFound) do
+      sleep 8 unless Fog.mocking?
+      listeners = [
+        {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => "#{@certificate['Arn']}fake"},
+      ]
+      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', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
+      ]
+      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)
+  end
+end

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

@@ -1,12 +1,13 @@
 Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
   @load_balancer_id = 'fog-test-elb'
+  @key_name = 'fog-test'
 
   tests('success') do
-    pending if Fog.mocking?
+    @certificate = 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'}]
+      listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
       AWS[:elb].create_load_balancer(zones, @load_balancer_id, listeners).body
     end
 
@@ -18,6 +19,19 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
       raises(Fog::AWS::ELB::NotFound) { AWS[:elb].describe_load_balancers('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']},
+      ]
+      AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners)
+      response = 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"]
+      end
+    end
+
     tests("#configure_health_check").formats(AWS::ELB::Formats::CONFIGURE_HEALTH_CHECK) do
       health_check = {
         'Target' => 'HTTP:80/index.html',
@@ -30,53 +44,18 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
       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
+    tests("#delete_load_balancer").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+      AWS[:elb].delete_load_balancer(@load_balancer_id).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
+    tests("#delete_load_balancer when non existant").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+      AWS[:elb].delete_load_balancer('non-existant').body
     end
 
-    tests("#delete_load_balancer").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+    tests("#delete_load_balancer when already deleted").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
       AWS[:elb].delete_load_balancer(@load_balancer_id).body
     end
+
+    AWS[:iam].delete_server_certificate(@key_name)
   end
 end