brightbox-cli 0.13.0

data/lib/brightbox-cli/vendor/fog/tests/aws/models/elb/model_tests.rb

@@ -0,0 +1,251 @@
+Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
+  @availability_zones = Fog::Compute[:aws].describe_availability_zones('state' => 'available').body['availabilityZoneInfo'].collect{ |az| az['zoneName'] }
+  @key_name = 'fog-test-model'
+
+  tests('success') do
+    tests('load_balancers') do
+      tests('getting a missing elb') do
+        returns(nil) { AWS[:elb].load_balancers.get('no-such-elb') }
+      end
+    end
+
+    tests('listeners') do
+      tests("default attributes") do
+        listener = AWS[:elb].listeners.new
+        tests('instance_port is 80').returns(80) { listener.instance_port }
+        tests('lb_port is 80').returns(80) { listener.lb_port }
+        tests('protocol is HTTP').returns('HTTP') { listener.protocol }
+        tests('policy_names is empty').returns([]) { listener.policy_names }
+      end
+
+      tests("specifying attributes") do
+        attributes = {:instance_port => 2000, :lb_port => 2001, :protocol => 'SSL', :policy_names => ['fake'] }
+        listener = AWS[:elb].listeners.new(attributes)
+        tests('instance_port is 2000').returns(2000) { listener.instance_port }
+        tests('lb_port is 2001').returns(2001) { listener.lb_port }
+        tests('protocol is SSL').returns('SSL') { listener.protocol }
+        tests('policy_names is [ fake ]').returns(['fake']) { listener.policy_names }
+      end
+    end
+
+    elb = nil
+    elb_id = 'fog-test'
+
+    tests('create') do
+      tests('without availability zones') do
+        elb = AWS[:elb].load_balancers.create(:id => elb_id)
+        tests("availability zones are correct").returns(@availability_zones.sort) { elb.availability_zones.sort }
+        tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
+        tests("created_at is set").returns(true) { Time === elb.created_at }
+        tests("policies is empty").returns([]) { elb.policies }
+        tests("default listener") do
+          tests("1 listener").returns(1) { elb.listeners.size }
+          tests("params").returns(AWS[:elb].listeners.new.to_params) { elb.listeners.first.to_params }
+        end
+      end
+
+      tests('with availability zones') do
+        azs = @availability_zones[1..-1]
+        elb2 = AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :availability_zones => azs)
+        tests("availability zones are correct").returns(azs.sort) { elb2.availability_zones.sort }
+        elb2.destroy
+      end
+
+      # Need to sleep here for IAM changes to propgate
+      tests('with ListenerDescriptions') do
+        @certificate = AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+        sleep(8) unless Fog.mocking?
+        listeners = [{
+            'Listener' => {
+              'LoadBalancerPort' => 2030, 'InstancePort' => 2030, 'Protocol' => 'HTTP'
+            },
+            'PolicyNames' => []
+          }, {
+            'Listener' => {
+              'LoadBalancerPort' => 443, 'InstancePort' => 443, 'Protocol' => 'HTTPS',
+              'SSLCertificateId' => @certificate['Arn']
+            },
+            'PolicyNames' => []
+          }]
+        elb3 = AWS[:elb].load_balancers.create(:id => "#{elb_id}-3", 'ListenerDescriptions' => listeners)
+        tests('there are 2 listeners').returns(2) { elb3.listeners.count }
+        tests('instance_port is 2030').returns(2030) { elb3.listeners.first.instance_port }
+        tests('lb_port is 2030').returns(2030) { elb3.listeners.first.lb_port }
+        tests('protocol is HTTP').returns('HTTP') { elb3.listeners.first.protocol }
+        tests('protocol is HTTPS').returns('HTTPS') { elb3.listeners.last.protocol }
+        elb3.destroy
+      end
+
+      tests('with invalid Server Cert ARN').raises(Fog::AWS::IAM::NotFound) do
+        listeners = [{
+          'Listener' => {
+          'LoadBalancerPort' => 443, 'InstancePort' => 80, 'Protocol' => 'HTTPS', "SSLCertificateId" => "fakecert"}
+        }]
+        AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners)
+      end
+    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
+      elb_get = AWS[:elb].load_balancers.get(elb_id)
+      tests('ids match').returns(elb_id) { elb_get.id }
+    end
+
+    tests('creating 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 = Fog::Compute[:aws].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(@availability_zones[1..-1])
+      returns(@availability_zones[0..0]) { elb.availability_zones.sort }
+    end
+
+    tests('enable_availability_zones') do
+      elb.enable_availability_zones(@availability_zones[1..-1])
+      returns(@availability_zones) { 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
+      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
+
+    AWS[:iam].delete_server_certificate(@key_name)
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/helper.rb

@@ -0,0 +1,5 @@
+def rds_default_server_params
+  { :id => uniq_id, :allocated_storage => 5, :engine => 'mysql',
+    :master_username => 'foguser', :password => 'fogpassword',
+    :backup_retention_period => 0 }
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/parameter_group_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests("AWS::RDS | parameter_group", ['aws', 'rds']) do
+
+  group_name = 'fog-test'
+  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
+
+  pending if Fog.mocking?
+  model_tests(AWS[:rds].parameter_groups, params, false) do
+    tests('#parameters') do
+      #search for a sample parameter
+      tests 'contains parameters' do
+        returns(true){ @instance.parameters.any? {|p| p.name == 'query_cache_size'}}
+      end
+    end
+
+    tests('#modify') do
+      @instance.modify([{:name => 'query_cache_size', :value => '6553600', :apply_method => 'immediate'}])
+
+      tests 'parameter has changed' do
+        returns('6553600'){@instance.parameters.detect {|p| p.name == 'query_cache_size'}.value}
+      end
+    end
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/parameter_groups_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests("AWS::RDS | parameter_groups", ['aws', 'rds']) do
+
+  group_name = 'fog-test'
+  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
+
+  pending if Fog.mocking?
+  collection_tests(AWS[:rds].parameter_groups, params, false)
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/security_group_tests.rb

@@ -0,0 +1,50 @@
+Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
+  group_name = 'fog-test'
+  params = {:id => group_name, :description => 'fog test'}
+
+  pending if Fog.mocking?
+  model_tests(AWS[:rds].security_groups, params, false) do
+
+    tests("#description").returns('fog test') { @instance.description }
+
+    tests("#authorize_ec2_security_group").succeeds do
+      @ec2_sec_group = Fog::Compute[:aws].security_groups.create(:name => 'fog-test', :description => 'fog test')
+
+      @instance.authorize_ec2_security_group(@ec2_sec_group.name)
+      returns('authorizing') do
+        @instance.ec2_security_groups.detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
+      end
+    end
+
+    @instance.wait_for { ready? }
+
+    tests("#revoke_ec2_security_group").succeeds do
+      @instance.revoke_ec2_security_group(@ec2_sec_group.name)
+
+      returns('revoking') do
+        @instance.ec2_security_groups.detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
+      end
+
+      @instance.wait_for { ready? }
+
+      returns(false) { @instance.ec2_security_groups.any?{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name} }
+      @ec2_sec_group.destroy
+    end
+
+    tests("#authorize_cidrip").succeeds do
+      @cidr = '127.0.0.1/32'
+      @instance.authorize_cidrip(@cidr)
+      returns('authorizing') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
+    end
+
+    @instance.wait_for { ready? }
+    tests("#revoke_cidrip").succeeds do
+      @instance.revoke_cidrip(@cidr)
+      returns('revoking') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
+      @instance.wait_for { ready? }
+      returns(false) { @instance.ip_ranges.any?{|h| h['CIDRIP'] == @cidr} }
+
+    end
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/security_groups_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests("AWS::RDS | security groups", ['aws', 'rds']) do
+  params = {:id => 'fog-test', :description => 'fog test'}
+
+  pending if Fog.mocking?
+  collection_tests(AWS[:rds].security_groups, params, false)
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/server_tests.rb

@@ -0,0 +1,104 @@
+Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  model_tests(AWS[:rds].servers, rds_default_server_params, false) do
+    # We'll need this later; create it early to avoid waiting
+    @instance_with_final_snapshot = AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
+
+    @instance.wait_for(20*60) { ready? }
+
+    tests('#snapshots') do
+      snapshot = nil
+
+      tests('#create').succeeds do
+        snapshot = @instance.snapshots.create(:id => 'fog-test-snapshot')
+      end
+
+      snapshot.wait_for {ready?}
+
+      @instance.reload
+      @instance.wait_for { ready? }
+
+      returns(true) { @instance.snapshots.map{|s| s.id}.include?(snapshot.id) }
+      snapshot.destroy
+    end
+
+    tests("#modify").succeeds do
+      orig_parameter_group = @instance.db_parameter_groups.first['DBParameterGroupName']
+      parameter_group = AWS[:rds].parameter_groups.create(:id => uniq_id, :family => 'mysql5.1', :description => 'fog-test')
+
+      orig_security_groups = @instance.db_security_groups.map{|h| h['DBSecurityGroupName']}
+      security_group = AWS[:rds].security_groups.create(:id => uniq_id, :description => 'fog-test')
+
+      modify_options = {
+        'DBParameterGroupName' => parameter_group.id,
+        'DBSecurityGroups' => orig_security_groups + [security_group.id]
+      }
+
+      @instance.modify(true, modify_options)
+      @instance.reload
+
+      returns(parameter_group.id, 'new parameter group') do
+        @instance.db_parameter_groups.first['DBParameterGroupName']
+      end
+
+      returns(true, "new security group") do
+        @instance.db_security_groups.any?{|hash| hash['DBSecurityGroupName'] == security_group.id}
+      end
+
+      @instance.reboot
+      @instance.reload.wait_for { state == 'rebooting' }
+      @instance.reload.wait_for { ready? }
+
+      # Restore back to original state using symbols
+      restore_options = {
+       :parameter_group_name => orig_parameter_group,
+       :security_group_names => orig_security_groups
+      }
+      @instance.modify(true, restore_options)
+
+      @instance.reboot
+      @instance.reload.wait_for { state == 'rebooting' }
+      @instance.reload.wait_for do
+        ready? &&
+          db_security_groups.all? {|hash| hash['Status'] == 'active'} &&
+          db_parameter_groups.all? {|hash| hash['ParameterApplyStatus'] == 'in-sync' }
+      end
+
+      parameter_group.destroy
+      security_group.destroy
+    end
+
+    tests("#reboot").succeeds do
+      @instance.reboot
+    end
+    @instance.reload.wait_for {state == 'rebooting'}
+    @instance.reload.wait_for { ready? }
+
+    tests('#create_read_replica').succeeds do
+      replica = @instance_with_final_snapshot.create_read_replica(uniq_id('fog-replica'))
+      @instance_with_final_snapshot.reload
+      returns([replica.id]) { @instance_with_final_snapshot.read_replica_identifiers }
+      returns(@instance_with_final_snapshot.id) { replica.read_replica_source }
+
+      replica.wait_for { ready? }
+      replica.destroy
+    end
+
+    test("Destroying with a final snapshot") do
+      final_snapshot_id = 'fog-test-snapshot'
+
+      @instance_with_final_snapshot.wait_for { ready? }
+      @instance_with_final_snapshot.destroy(final_snapshot_id)
+      returns(true, "Final snapshot created") do
+        @final_snapshot = AWS[:rds].snapshots.get(final_snapshot_id)
+        !@final_snapshot.nil?
+      end
+
+      @final_snapshot.wait_for { ready? }
+      @final_snapshot.destroy
+    end
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/servers_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests("AWS::RDS | servers", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  collection_tests(AWS[:rds].servers, rds_default_server_params, false) do
+    @instance.wait_for { ready? }
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/snapshot_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::RDS | snapshot", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  @server = AWS[:rds].servers.create(rds_default_server_params)
+  @server.wait_for { ready? }
+
+  params = {:id => uniq_id, :instance_id => @server.id}
+  model_tests(AWS[:rds].snapshots, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end
+

data/lib/brightbox-cli/vendor/fog/tests/aws/models/rds/snapshots_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::RDS | snapshots", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  @server = AWS[:rds].servers.create(rds_default_server_params)
+  @server.wait_for { ready? }
+
+  params = {:id => uniq_id, :instance_id => @server.id}
+  collection_tests(AWS[:rds].snapshots, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end
+

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/auto_scaling/auto_scaling_tests.rb

@@ -0,0 +1,80 @@
+Shindo.tests('AWS::AutoScaling | auto_scaling_tests', ['aws', 'auto_scaling']) do
+  @asg_name = 'fog-test-asg'
+  @lc_name = 'fog-test-lc'
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests("#describe_adjustment_types").formats(AWS::AutoScaling::Formats::DESCRIBE_ADJUSTMENT_TYPES) do
+      AWS[:auto_scaling].describe_adjustment_types.body
+    end
+    tests("#describe_metric_collection_types").formats(AWS::AutoScaling::Formats::DESCRIBE_METRIC_COLLECTION_TYPES) do
+      AWS[:auto_scaling].describe_metric_collection_types.body
+    end
+    tests("#describe_scaling_process_types").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_PROCESS_TYPES) do
+      AWS[:auto_scaling].describe_scaling_process_types.body
+    end
+
+    tests("#create_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
+      image_id = 'ami-8c1fece5'
+      instance_type = 't1.micro'
+      #listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'http'}]
+      AWS[:auto_scaling].create_launch_configuration(image_id, instance_type, @lc_name).body
+    end
+
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      AWS[:auto_scaling].describe_launch_configurations().body
+    end
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => @lc_name).body
+    end
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => [@lc_name]).body
+    end
+
+    tests("#create_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
+      zones = ['us-east-1d']
+      max_size = 0
+      min_size = 0
+      AWS[:auto_scaling].create_auto_scaling_group(@asg_name, zones, @lc_name, max_size, min_size).body
+    end
+
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      AWS[:auto_scaling].describe_auto_scaling_groups().body
+    end
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => @asg_name).body
+    end
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => [@asg_name]).body
+    end
+
+    tests("#describe_auto_scaling_instances").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_INSTANCES) do
+      AWS[:auto_scaling].describe_auto_scaling_instances().body
+    end
+
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities().body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => '1').body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => ['1', '2']).body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities('AutoScalingGroupName' => @asg_name).body
+    end
+
+    tests("#set_desired_capacity").formats(AWS::AutoScaling::Formats::BASIC) do
+      desired_capacity = 0
+      AWS[:auto_scaling].set_desired_capacity(@asg_name, desired_capacity).body
+    end
+    tests("#delete_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
+      AWS[:auto_scaling].delete_auto_scaling_group(@asg_name).body
+    end
+    tests("#delete_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
+      AWS[:auto_scaling].delete_launch_configuration(@lc_name).body
+    end
+  end
+end