fog-aws 0.0.5

data/tests/requests/auto_scaling/model_tests.rb

@@ -0,0 +1,233 @@
+Shindo.tests('AWS::AutoScaling | model_tests', ['aws', 'auto_scaling']) do
+
+  tests('success') do
+    lc = nil
+    lc_id = 'fog-model-lc'
+
+    tests('configurations') do
+      tests('getting a missing configuration') do
+        returns(nil) { Fog::AWS[:auto_scaling].configurations.get('fog-no-such-lc') }
+      end
+
+      tests('create configuration') do
+        lc = Fog::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 = Fog::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 = Fog::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
+          Fog::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) { Fog::AWS[:auto_scaling].groups.get('fog-no-such-asg') }
+      end
+
+      asg = nil
+      asg_id = 'fog-model-asg'
+
+      tests('create') do
+        asg = Fog::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 = Fog::AWS[:auto_scaling].groups.all.map{|e| e.id}
+        tests("contains asg").returns(true) { asg_ids.include? asg_id }
+      end
+
+      tests('get') do
+        asg2 = Fog::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
+          Fog::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 = Fog::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/requests/auto_scaling/notification_configuration_tests.rb

@@ -0,0 +1,124 @@
+Shindo.tests('AWS::AutoScaling | notification configuration requests', ['aws', 'auto_scaling']) do
+
+  image_id = {  # Ubuntu 12.04 LTS 64-bit EBS
+    'ap-northeast-1' => 'ami-60c77761',
+    'ap-southeast-1' => 'ami-a4ca8df6',
+    'ap-southeast-2' => 'ami-fb8611c1',
+    'eu-west-1'      => 'ami-e1e8d395',
+    'sa-east-1'      => 'ami-8cd80691',
+    'us-east-1'      => 'ami-a29943cb',
+    'us-west-1'      => 'ami-87712ac2',
+    'us-west-2'      => 'ami-20800c10'
+  }
+
+  now = Time.now.utc.to_i
+  lc_name = "fog-test-#{now}"
+  asg_name = "fog-test-#{now}"
+
+  topic_name = "fog-test-#{now}"
+  begin
+    topic = Fog::AWS[:sns].create_topic(topic_name).body
+    topic_arn = topic['TopicArn']
+  rescue Fog::Errors::MockNotImplemented
+    topic_arn = Fog::AWS::Mock.arn('sns', Fog::AWS[:auto_scaling].data[:owner_id], "fog-test-#{now}", Fog::AWS[:auto_scaling].region)
+  end
+
+  lc = Fog::AWS[:auto_scaling].create_launch_configuration(image_id[Fog::AWS[:auto_scaling].region], 't1.micro', lc_name)
+  asg = Fog::AWS[:auto_scaling].create_auto_scaling_group(asg_name, "#{Fog::AWS[:auto_scaling].region}a", lc_name, 0, 0)
+
+  tests('raises') do
+    tests("#put_notification_configuration(non-existent-group)").raises(Fog::AWS::AutoScaling::ValidationError) do
+      Fog::AWS[:auto_scaling].put_notification_configuration('fog-test-nonexistent-group', 'autoscaling:TEST_NOTIFICATION', topic_arn)
+    end
+
+    tests("#put_notification_configuration(null-types)").raises(Fog::AWS::AutoScaling::ValidationError) do
+      Fog::AWS[:auto_scaling].put_notification_configuration(asg_name, [], topic_arn)
+    end
+  end
+
+  tests('success') do
+    tests("#put_notification_configuration(string)").formats(AWS::AutoScaling::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].put_notification_configuration(asg_name, 'autoscaling:TEST_NOTIFICATION', topic_arn).body
+    end
+
+    tests("#describe_notification_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:auto_scaling].describe_notification_configurations('AutoScalingGroupNames' => asg_name).body
+      notification_configurations = body['DescribeNotificationConfigurationsResult']['NotificationConfigurations']
+      returns(true, 'exactly 1 configurations') do
+        notification_configurations.size == 1
+      end
+      returns(true) do
+        config = notification_configurations.first
+        config['AutoScalingGroupName'] == asg_name && config['TopicARN'] == topic_arn && config['NotificationType'] == 'autoscaling:TEST_NOTIFICATION'
+      end
+      body
+    end
+
+    tests("#put_notification_configuration(array)").formats(AWS::AutoScaling::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].put_notification_configuration(asg_name, ['autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'], topic_arn).body
+    end
+
+    tests("#describe_notification_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:auto_scaling].describe_notification_configurations('AutoScalingGroupName' => asg_name).body
+      notification_configurations = body['DescribeNotificationConfigurationsResult']['NotificationConfigurations']
+      returns(true, 'exactly 2 configurations') do
+        notification_configurations.size == 2
+      end
+      [ 'autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'].each do |type|
+        returns(true) do
+          notification_configurations.any? do |config|
+            config['AutoScalingGroupName'] == asg_name && config['TopicARN'] == topic_arn && config['NotificationType'] == type
+          end
+        end
+      end
+      body
+    end
+
+    tests("#describe_notification_configurations(all)").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:auto_scaling].describe_notification_configurations().body
+      notification_configurations = body['DescribeNotificationConfigurationsResult']['NotificationConfigurations']
+      returns(true, 'at least 2 configurations') do
+        notification_configurations.size >= 2
+      end
+      [ 'autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'].each do |type|
+        returns(true) do
+          notification_configurations.any? do |config|
+            config['AutoScalingGroupName'] == asg_name && config['TopicARN'] == topic_arn && config['NotificationType'] == type
+          end
+        end
+      end
+
+      body
+    end
+
+    tests("#delete_notification_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].delete_notification_configuration(asg_name, topic_arn).body
+    end
+
+    tests("#describe_notification_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:auto_scaling].describe_notification_configurations('AutoScalingGroupNames' => asg_name).body
+      returns(true) do
+        body['DescribeNotificationConfigurationsResult']['NotificationConfigurations'].empty?
+      end
+      body
+    end
+  end
+
+  Fog::AWS[:auto_scaling].delete_auto_scaling_group(asg_name)
+  Fog::AWS[:auto_scaling].delete_launch_configuration(lc_name)
+
+  if topic
+    begin
+      Fog::AWS[:sns].delete_topic(topic_arn)
+    rescue Fog::Errors::MockNotImplemented
+    end
+  end
+
+end

data/tests/requests/auto_scaling/tag_tests.rb

@@ -0,0 +1,63 @@
+Shindo.tests('AWS::AutoScaling | tag requests', ['aws', 'auto_scaling']) do
+
+  image_id = {  # Ubuntu 12.04 LTS 64-bit EBS
+    'ap-northeast-1' => 'ami-60c77761',
+    'ap-southeast-1' => 'ami-a4ca8df6',
+    'ap-southeast-2' => 'ami-fb8611c1',
+    'eu-west-1'      => 'ami-e1e8d395',
+    'sa-east-1'      => 'ami-8cd80691',
+    'us-east-1'      => 'ami-a29943cb',
+    'us-west-1'      => 'ami-87712ac2',
+    'us-west-2'      => 'ami-20800c10'
+  }
+
+  now = Time.now.utc.to_i
+  lc_name = "fog-test-#{now}"
+  asg_name = "fog-test-#{now}"
+
+  asg_tag = {
+    'Key'               => 'Name',
+    'PropagateAtLaunch' => true,
+    'ResourceId'        => asg_name,
+    'ResourceType'      => 'auto-scaling-group',
+    'Value'             => asg_name
+  }
+
+  lc = Fog::AWS[:auto_scaling].create_launch_configuration(image_id[Fog::AWS[:auto_scaling].region], 't1.micro', lc_name)
+  asg = Fog::AWS[:auto_scaling].create_auto_scaling_group(asg_name, "#{Fog::AWS[:auto_scaling].region}a", lc_name, 0, 0, 'Tags' => [asg_tag])
+
+  tests('raises') do
+    tests("#create_or_update_tags(empty)").raises(Fog::AWS::AutoScaling::ValidationError) do
+      Fog::AWS[:auto_scaling].create_or_update_tags([])
+    end
+
+    tests("#delete_tags(empty)").raises(Fog::AWS::AutoScaling::ValidationError) do
+      Fog::AWS[:auto_scaling].delete_tags([])
+    end
+  end
+
+  tests('success') do
+    tests("#describe_auto_scaling_groups(#{asg_name}").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      body = Fog::AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => asg_name).body
+      auto_scaling_group = body['DescribeAutoScalingGroupsResult']['AutoScalingGroups'].first
+      returns(true) { auto_scaling_group.key?('Tags') }
+      returns(true) { auto_scaling_group['Tags'].size == 1 }
+      returns(true) { auto_scaling_group['Tags'].first == asg_tag }
+      body
+    end
+
+    tests("#describe_tags").formats(AWS::AutoScaling::Formats::DESCRIBE_TAGS) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:auto_scaling].describe_tags.body
+      tags = body['DescribeTagsResult']['Tags']
+      returns(true) { tags.any? {|tag| tag == asg_tag} }
+      body
+    end
+
+    # TODO: more tests!
+  end
+
+  Fog::AWS[:auto_scaling].delete_auto_scaling_group(asg_name)
+  Fog::AWS[:auto_scaling].delete_launch_configuration(lc_name)
+
+end

data/tests/requests/beanstalk/application_tests.rb

@@ -0,0 +1,140 @@
+Shindo.tests('AWS::ElasticBeanstalk | application_tests', ['aws', 'beanstalk']) do
+
+  def unique_name(prefix)
+    #get time (with 1/100th of sec accuracy)
+    #want unique domain name and if provider is fast, this can be called more than once per second
+    time = Time.now.to_i.to_s
+    prefix + time
+  end
+
+  unless Fog.mocking?
+    @beanstalk = Fog::AWS[:beanstalk]
+  end
+
+  @test_description = "A unique description."
+
+  @test_app_name = unique_name("fog-test-app-")
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    @describe_applications_format = {
+        'DescribeApplicationsResult' => {
+            'Applications' => [
+                'ApplicationName' => String,
+                'ConfigurationTemplates' => [String],
+                'Description' => Fog::Nullable::String,
+                'DateCreated' => Time,
+                'DateUpdated' => Time,
+                'Versions' => [String]
+            ]},
+        'ResponseMetadata' => {'RequestId'=> String},
+    }
+
+    tests("#describe_applications format").formats(@describe_applications_format) do
+      result = @beanstalk.describe_applications.body
+    end
+
+    test("#create_application") {
+      response = @beanstalk.create_application({
+                                                   'ApplicationName' => @test_app_name,
+                                                   'Description' => @test_description
+                                               })
+
+      result = false
+      if response.status == 200
+
+        app_info = response.body['CreateApplicationResult']['Application']
+        if app_info
+          if app_info['ApplicationName'] == @test_app_name &&
+              app_info['Description'] == @test_description &&
+              app_info['ConfigurationTemplates'].empty? &&
+              app_info['Versions'].empty?
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("#describe_applications all") {
+      response = @beanstalk.describe_applications
+
+      result = false
+      if response.status == 200
+        apps = response.body['DescribeApplicationsResult']['Applications']
+        apps.each { |app_info|
+          if app_info
+            if app_info['ApplicationName'] == @test_app_name &&
+                app_info['Description'] == @test_description &&
+                app_info['ConfigurationTemplates'].empty? &&
+                app_info['Versions'].empty?
+              result = true
+            end
+          end
+        }
+      end
+
+      result
+    }
+
+    test("#create_application filter") {
+      # Test for a specific app
+      response = @beanstalk.describe_applications([@test_app_name])
+
+      result = false
+      if response.status == 200
+        apps = response.body['DescribeApplicationsResult']['Applications']
+        if apps && apps.length == 1
+          app_info = apps.first
+          if app_info['ApplicationName'] == @test_app_name &&
+              app_info['Description'] == @test_description &&
+              app_info['ConfigurationTemplates'].empty? &&
+              app_info['Versions'].empty?
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("#update_application description") {
+
+      @test_description = "A completely new description."
+
+      response = @beanstalk.update_application({
+                                                   'ApplicationName' => @test_app_name,
+                                                   'Description' => @test_description
+                                               })
+
+      result = false
+      if response.status == 200
+        app_info = response.body['UpdateApplicationResult']['Application']
+        if app_info
+          if app_info['ApplicationName'] == @test_app_name &&
+              app_info['Description'] == @test_description &&
+              app_info['ConfigurationTemplates'].empty? &&
+              app_info['Versions'].empty?
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("#delete_application") {
+      response = @beanstalk.delete_application(@test_app_name)
+
+      result = false
+      if response.status == 200
+          result = true
+      end
+
+      result
+    }
+
+  end
+end