fog 1.26.0 → 1.27.0

data/tests/aws/requests/rds/instance_option_tests.rb

@@ -1,21 +0,0 @@
-Shindo.tests('AWS::RDS | db instance option requests', ['aws', 'rds']) do
-  tests('success') do
-
-    tests("#describe_orderable_db_instance_options('mysql)").formats(AWS::RDS::Formats::DESCRIBE_ORDERABLE_DB_INSTANCE_OPTION) do
-
-      body = Fog::AWS[:rds].describe_orderable_db_instance_options('mysql').body
-
-      returns(2) {body['DescribeOrderableDBInstanceOptionsResult']['OrderableDBInstanceOptions'].length}
-
-      group = body['DescribeOrderableDBInstanceOptionsResult']['OrderableDBInstanceOptions'].first
-      returns( true ) { group['MultiAZCapable'] }
-      returns( 'mysql' ) { group['Engine'] }
-      returns( true ) { group['ReadReplicaCapable'] }
-      returns( true ) { group['AvailabilityZones'].length >= 1 }
-
-      body
-    end
-
-  end
-
-end

data/tests/aws/requests/rds/instance_tests.rb

@@ -1,133 +0,0 @@
-Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
-  # Disabled due to https://github.com/fog/fog/1546
-  pending
-
-  # random_differentiator
-  # Useful when rapidly re-running tests, so we don't have to wait
-  # serveral minutes for deleted servers to disappear
-  suffix = rand(65536).to_s(16)
-
-  @db_instance_id       = "fog-test-#{suffix}"
-  @db_replica_id        = "fog-replica-#{suffix}"
-  @db_snapshot_id       = "fog-snapshot"
-  @db_final_snapshot_id = "fog-final-snapshot"
-
-  tests('success') do
-
-    tests("#create_db_instance").formats(AWS::RDS::Formats::CREATE_DB_INSTANCE) do
-      result = Fog::AWS[:rds].create_db_instance(@db_instance_id,
-                                                 'AllocatedStorage' => 5,
-                                                 'DBInstanceClass' => 'db.m1.small',
-                                                 'Engine' => 'mysql',
-                                                 'EngineVersion' => '5.1.50',
-                                                 'MasterUsername' => 'foguser',
-                                                 'BackupRetentionPeriod' => 1,
-                                                 'MasterUserPassword' => 'fogpassword').body
-
-      instance = result['CreateDBInstanceResult']['DBInstance']
-      returns('creating') { instance['DBInstanceStatus'] }
-      result
-    end
-
-    tests("#describe_db_instances").formats(AWS::RDS::Formats::DESCRIBE_DB_INSTANCES) do
-      Fog::AWS[:rds].describe_db_instances.body
-    end
-
-    server = Fog::AWS[:rds].servers.get(@db_instance_id)
-    server.wait_for { ready? }
-
-    new_storage = 6
-    tests("#modify_db_instance with immediate apply").formats(AWS::RDS::Formats::MODIFY_DB_INSTANCE) do
-      body = Fog::AWS[:rds].modify_db_instance(@db_instance_id, true, 'AllocatedStorage' => new_storage).body
-      tests 'pending storage' do
-        instance = body['ModifyDBInstanceResult']['DBInstance']
-        returns(new_storage) { instance['PendingModifiedValues']['AllocatedStorage'] }
-      end
-      body
-    end
-
-    server.wait_for { state == 'modifying' }
-    server.wait_for { state == 'available' }
-
-    tests 'new storage' do
-      returns(new_storage) { server.allocated_storage }
-    end
-
-    tests("reboot db instance") do
-      tests("#reboot").formats(AWS::RDS::Formats::REBOOT_DB_INSTANCE) do
-        Fog::AWS[:rds].reboot_db_instance(@db_instance_id).body
-      end
-    end
-
-    server.wait_for { state == 'rebooting' }
-    server.wait_for { state == 'available' }
-
-    tests("#create_db_snapshot").formats(AWS::RDS::Formats::CREATE_DB_SNAPSHOT) do
-      body = Fog::AWS[:rds].create_db_snapshot(@db_instance_id, @db_snapshot_id).body
-      returns('creating') { body['CreateDBSnapshotResult']['DBSnapshot']['Status'] }
-      body
-    end
-
-    tests("#describe_db_snapshots").formats(AWS::RDS::Formats::DESCRIBE_DB_SNAPSHOTS) do
-      body = Fog::AWS[:rds].describe_db_snapshots.body
-    end
-
-    server.wait_for { state == 'available' }
-
-    tests("#create read replica").formats(AWS::RDS::Formats::CREATE_READ_REPLICA) do
-      Fog::AWS[:rds].create_db_instance_read_replica(@db_replica_id, @db_instance_id).body
-    end
-
-    replica = Fog::AWS[:rds].servers.get(@db_replica_id)
-    replica.wait_for { ready? }
-
-    tests("replica source") do
-      returns(@db_instance_id) { replica.read_replica_source }
-    end
-    server.reload
-
-    tests("replica identifiers") do
-      returns([@db_replica_id]) { server.read_replica_identifiers }
-    end
-
-    tests("#promote read replica").formats(AWS::RDS::Formats::PROMOTE_READ_REPLICA) do
-      Fog::AWS[:rds].promote_read_replica(@db_replica_id).body
-    end
-
-    tests("#delete_db_instance").formats(AWS::RDS::Formats::DELETE_DB_INSTANCE) do
-      #server.wait_for { state == 'available' }
-      Fog::AWS[:rds].delete_db_instance(@db_replica_id, nil, true)
-      body = Fog::AWS[:rds].delete_db_instance(@db_instance_id, @db_final_snapshot_id).body
-
-      tests "final snapshot" do
-        returns('creating') { Fog::AWS[:rds].describe_db_snapshots(:snapshot_id => @db_final_snapshot_id).body['DescribeDBSnapshotsResult']['DBSnapshots'].first['Status'] }
-      end
-      body
-    end
-
-    tests("#delete_db_snapshot").formats(AWS::RDS::Formats::DELETE_DB_SNAPSHOT) do
-      Fog::AWS[:rds].snapshots.get(@db_snapshot_id).wait_for { ready? }
-      Fog::AWS[:rds].delete_db_snapshot(@db_snapshot_id).body
-    end
-
-    tests("snapshot.destroy") do
-      snapshot = Fog::AWS[:rds].snapshots.get(@db_final_snapshot_id)
-      snapshot.wait_for { ready? }
-      snapshot.destroy
-      returns(nil) { Fog::AWS[:rds].snapshots.get(@db_final_snapshot_id) }
-    end
-
-  end
-
-  tests('failure') do
-    tests "deleting nonexisting instance" do
-      raises(Fog::AWS::RDS::NotFound) { Fog::AWS[:rds].delete_db_instance('doesnexist', 'irrelevant') }
-    end
-    tests "deleting non existing snapshot" do
-      raises(Fog::AWS::RDS::NotFound) { Fog::AWS[:rds].delete_db_snapshot('doesntexist') }
-    end
-    tests "modifying non existing instance" do
-      raises(Fog::AWS::RDS::NotFound) { Fog::AWS[:rds].modify_db_instance 'doesntexit', true, 'AllocatedStorage' => 10 }
-    end
-  end
-end

data/tests/aws/requests/rds/log_file_tests.rb

@@ -1,19 +0,0 @@
-Shindo.tests('AWS::RDS | log file requests', %w[aws rds]) do
-  tests('success') do
-    pending if Fog.mocking?
-
-    suffix = rand(65536).to_s(16)
-    @db_instance_id = "fog-test-#{suffix}"
-
-    tests('#describe_db_log_files').formats(AWS::RDS::Formats::DESCRIBE_DB_LOG_FILES) do
-      result = Fog::AWS[:rds].describe_db_log_files(@db_instance_id).body['DescribeDBLogFilesResult']
-      returns(true) { result['DBLogFiles'].size > 0 }
-      result
-    end
-
-  end
-
-  tests('failures') do
-    raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_log_files('doesntexist')}
-  end
-end

data/tests/aws/requests/rds/parameter_group_tests.rb

@@ -1,62 +0,0 @@
-Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
-  tests('success') do
-
-    tests("#create_db_parameter_groups").formats(AWS::RDS::Formats::CREATE_DB_PARAMETER_GROUP) do
-      body = Fog::AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description').body
-
-      returns( 'mysql5.1') { body['CreateDBParameterGroupResult']['DBParameterGroup']['DBParameterGroupFamily']}
-      returns( 'fog-group') { body['CreateDBParameterGroupResult']['DBParameterGroup']['DBParameterGroupName']}
-      returns( 'Some description') { body['CreateDBParameterGroupResult']['DBParameterGroup']['Description']}
-
-      body
-    end
-
-    Fog::AWS[:rds].create_db_parameter_group('other-fog-group', 'MySQL5.1', 'Some description')
-
-    tests("#describe_db_parameter_groups").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
-
-      body = Fog::AWS[:rds].describe_db_parameter_groups().body
-
-      returns(4) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}
-      body
-    end
-
-    tests("#describe_db_parameter_groups('fog-group)").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
-
-      body = Fog::AWS[:rds].describe_db_parameter_groups('fog-group').body
-
-      returns(1) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}
-
-      group = body['DescribeDBParameterGroupsResult']['DBParameterGroups'].first
-      returns( 'mysql5.1') { group['DBParameterGroupFamily']}
-      returns( 'fog-group') { group['DBParameterGroupName']}
-      returns( 'Some description') { group['Description']}
-
-      body
-    end
-
-    tests("delete_db_parameter_group").formats(AWS::RDS::Formats::BASIC) do
-      body = Fog::AWS[:rds].delete_db_parameter_group('fog-group').body
-
-      raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_parameter_groups('fog-group')}
-
-      body
-    end
-
-    Fog::AWS[:rds].delete_db_parameter_group('other-fog-group')
-  end
-
-  tests("failures") do
-    raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_parameter_groups('doesntexist')}
-    raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].delete_db_parameter_group('doesntexist')}
-
-    tests "creating second group with same id" do
-      Fog::AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description')
-      raises(Fog::AWS::RDS::IdentifierTaken) {Fog::AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description')}
-    end
-
-    Fog::AWS[:rds].delete_db_parameter_group('fog-group')
-
-  end
-
-end

data/tests/aws/requests/rds/parameter_request_tests.rb

@@ -1,34 +0,0 @@
-Shindo.tests('AWS::RDS | parameter requests', ['aws', 'rds']) do
-  tests('success') do
-    pending if Fog.mocking?
-
-    Fog::AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description')
-
-    tests('#modify_db_parameter_group').formats(AWS::RDS::Formats::MODIFY_PARAMETER_GROUP) do
-      body = Fog::AWS[:rds].modify_db_parameter_group('fog-group',[
-        {'ParameterName' => 'query_cache_size',
-        'ParameterValue' => '12345',
-        'ApplyMethod' => 'immediate'}
-      ]).body
-
-      body
-    end
-
-    tests('#describe_db_parameters').formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETERS) do
-      Fog::AWS[:rds].describe_db_parameters('fog-group', :max_records => 20).body
-    end
-
-    tests("#describe_db_parameters :source => 'user'")do
-      body = Fog::AWS[:rds].describe_db_parameters('fog-group', :source => 'user').body
-      returns(1){ body['DescribeDBParametersResult']['Parameters'].length}
-
-      param = body['DescribeDBParametersResult']['Parameters'].first
-      returns('query_cache_size'){param['ParameterName']}
-      returns('12345'){param['ParameterValue']}
-      returns(true){param['IsModifiable']}
-      returns('query_cache_size'){param['ParameterName']}
-    end
-    Fog::AWS[:rds].delete_db_parameter_group('fog-group')
-
-  end
-end

data/tests/aws/requests/rds/security_group_tests.rb

@@ -1,101 +0,0 @@
-Shindo.tests('AWS::RDS | security group requests', ['aws', 'rds']) do
-  suffix = rand(65536).to_s(16)
-
-  @sec_group_name  = "fog-sec-group-#{suffix}"
-  if Fog.mocking?
-    @owner_id = '123456780'
-  else
-    @owner_id = Fog::AWS[:rds].security_groups.get('default').owner_id
-  end
-
-  tests('success') do
-
-    tests("#create_db_security_group").formats(AWS::RDS::Formats::CREATE_DB_SECURITY_GROUP) do
-      body = Fog::AWS[:rds].create_db_security_group(@sec_group_name, 'Some description').body
-
-      returns( @sec_group_name) { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['DBSecurityGroupName']}
-      returns( 'Some description') { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['DBSecurityGroupDescription']}
-      returns( []) { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['EC2SecurityGroups']}
-      returns( []) { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['IPRanges']}
-
-      body
-    end
-
-    tests("#describe_db_security_groups").formats(AWS::RDS::Formats::DESCRIBE_DB_SECURITY_GROUP) do
-      Fog::AWS[:rds].describe_db_security_groups.body
-    end
-
-    tests("#authorize_db_security_group_ingress CIDR").formats(AWS::RDS::Formats::AUTHORIZE_DB_SECURITY_GROUP) do
-      @cidr = '0.0.0.0/0'
-      body = Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'CIDRIP'=>@cidr}).body
-
-      returns("authorizing") { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['IPRanges'].find{|h| h['CIDRIP'] == @cidr}['Status']}
-      body
-    end
-
-    sec_group = Fog::AWS[:rds].security_groups.get(@sec_group_name)
-    sec_group.wait_for {ready?}
-
-    tests("#authorize_db_security_group_ingress another CIDR").formats(AWS::RDS::Formats::AUTHORIZE_DB_SECURITY_GROUP) do
-      @cidr = "10.0.0.0/24"
-      body = Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'CIDRIP'=>@cidr}).body
-
-      returns("authorizing") { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['IPRanges'].find{|h| h['CIDRIP'] == @cidr}['Status']}
-      body
-    end
-
-    sec_group = Fog::AWS[:rds].security_groups.get(@sec_group_name)
-    sec_group.wait_for {ready?}
-
-    tests("#count CIDRIP").formats(AWS::RDS::Formats::DESCRIBE_DB_SECURITY_GROUP) do
-      body = Fog::AWS[:rds].describe_db_security_groups(@sec_group_name).body
-      returns(2) { body['DescribeDBSecurityGroupsResult']['DBSecurityGroups'][0]['IPRanges'].size }
-      body
-    end
-
-    tests("#revoke_db_security_group_ingress CIDR").formats(AWS::RDS::Formats::REVOKE_DB_SECURITY_GROUP) do
-      @cidr = '0.0.0.0/0'
-      body = Fog::AWS[:rds].revoke_db_security_group_ingress(@sec_group_name,{'CIDRIP'=> @cidr}).body
-      returns("revoking") { body['RevokeDBSecurityGroupIngressResult']['DBSecurityGroup']['IPRanges'].find{|h| h['CIDRIP'] == @cidr}['Status']}
-      body
-    end
-
-    tests("#authorize_db_security_group_ingress EC2").formats(AWS::RDS::Formats::AUTHORIZE_DB_SECURITY_GROUP) do
-      @ec2_sec_group = 'default'
-      body = Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'EC2SecurityGroupName' => @ec2_sec_group, 'EC2SecurityGroupOwnerId' => @owner_id}).body
-
-      returns("authorizing") { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['Status']}
-      returns(@owner_id) { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['EC2SecurityGroupOwnerId']}
-      body
-    end
-
-    tests("duplicate #authorize_db_security_group_ingress EC2").raises(Fog::AWS::RDS::AuthorizationAlreadyExists) do
-      @ec2_sec_group = 'default'
-
-      Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'EC2SecurityGroupName' => @ec2_sec_group, 'EC2SecurityGroupOwnerId' => @owner_id})
-    end
-
-    sec_group = Fog::AWS[:rds].security_groups.get(@sec_group_name)
-    sec_group.wait_for {ready?}
-
-    tests("#revoke_db_security_group_ingress EC2").formats(AWS::RDS::Formats::REVOKE_DB_SECURITY_GROUP) do
-      @ec2_sec_group = 'default'
-
-      body = Fog::AWS[:rds].revoke_db_security_group_ingress(@sec_group_name,{'EC2SecurityGroupName' => @ec2_sec_group, 'EC2SecurityGroupOwnerId' => @owner_id}).body
-
-      returns("revoking") { body['RevokeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['Status']}
-      body
-    end
-
-
-    #TODO, authorize ec2 security groups
-
-    tests("#delete_db_security_group").formats(AWS::RDS::Formats::BASIC) do
-      body = Fog::AWS[:rds].delete_db_security_group(@sec_group_name).body
-
-      raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_security_groups(@sec_group_name)}
-
-      body
-    end
-  end
-end

data/tests/aws/requests/rds/subnet_groups_tests.rb

@@ -1,52 +0,0 @@
-Shindo.tests('AWS::RDS | subnet group requests', ['aws', 'rds']) do
-  # random_differentiator
-  # Useful when rapidly re-running tests, so we don't have to wait
-  # serveral minutes for deleted VPCs/subnets to disappear
-  suffix = rand(65536).to_s(16)
-  @subnet_group_name = "fog-test-#{suffix}"
-
-  vpc_range = rand(245) + 10
-  @vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => "10.#{vpc_range}.0.0/16")
-
-  # Create 4 subnets in this VPC, each one in a different AZ
-  subnet_az = 'us-east-1a'
-  subnet_range = 8
-  @subnets = (1..4).map do
-    subnet = Fog::Compute[:aws].create_subnet(@vpc.id, "10.#{vpc_range}.#{subnet_range}.0/24",
-      'AvailabilityZone' => subnet_az).body['subnet']
-    subnet_az = subnet_az.succ
-    subnet_range *= 2
-    subnet
-  end
-
-  tests('success') do
-
-    subnet_ids = @subnets.map { |sn| sn['subnetId'] }.to_a
-
-    tests("#create_db_subnet_group").formats(AWS::RDS::Formats::CREATE_DB_SUBNET_GROUP) do
-      result = Fog::AWS[:rds].create_db_subnet_group(@subnet_group_name, subnet_ids, 'A subnet group').body
-
-      returns(@subnet_group_name) { result['CreateDBSubnetGroupResult']['DBSubnetGroup']['DBSubnetGroupName'] }
-      returns('A subnet group') { result['CreateDBSubnetGroupResult']['DBSubnetGroup']['DBSubnetGroupDescription'] }
-      returns(@vpc.id) { result['CreateDBSubnetGroupResult']['DBSubnetGroup']['VpcId'] }
-      returns(subnet_ids.sort) { result['CreateDBSubnetGroupResult']['DBSubnetGroup']['Subnets'].sort }
-
-      result
-    end
-
-    tests("#describe_db_subnet_groups").formats(AWS::RDS::Formats::DESCRIBE_DB_SUBNET_GROUPS) do
-      Fog::AWS[:rds].describe_db_subnet_groups.body
-    end
-
-    tests("#delete_db_subnet_group").formats(AWS::RDS::Formats::BASIC) do
-      Fog::AWS[:rds].delete_db_subnet_group(@subnet_group_name).body
-    end
-
-  end
-
-  @subnets.each do |sn|
-    Fog::Compute[:aws].delete_subnet(sn['subnetId'])
-  end
-  @vpc.destroy
-
-end

data/tests/aws/requests/rds/tagging_tests.rb

@@ -1,78 +0,0 @@
-Shindo.tests('AWS::RDS | tagging requests', ['aws', 'rds']) do
-  @rds = Fog::AWS[:rds]
-  @db_instance_id = "fog-test-#{rand(65536).to_s(16)}"
-  Formatador.display_line "Creating RDS instance #{@db_instance_id}"
-  @rds.create_db_instance(@db_instance_id, 'AllocatedStorage' => 5,
-        'DBInstanceClass' => 'db.t1.micro', 'Engine' => 'mysql',
-        'MasterUsername' => 'foguser', 'MasterUserPassword' => 'fogpassword')
-  Formatador.display_line "Waiting for instance #{@db_instance_id} to be ready"
-  @db = @rds.servers.get(@db_instance_id)
-  @db.wait_for { ready? }
-
-  tests('success') do
-
-    single_tag  = {'key1' => 'value1'}
-    two_tags    = {'key2' => 'value2', 'key3' => 'value3'}
-
-    tests("#add_tags_to_resource with a single tag").
-    formats(AWS::RDS::Formats::BASIC) do
-      result = @rds.add_tags_to_resource(@db_instance_id, single_tag).body
-      returns(single_tag) do
-        @rds.list_tags_for_resource(@db_instance_id).
-          body['ListTagsForResourceResult']['TagList']
-      end
-      result
-    end
-
-    tests("#add_tags_to_resource with a multiple tags").
-    formats(AWS::RDS::Formats::BASIC) do
-      result = @rds.add_tags_to_resource(@db_instance_id, two_tags).body
-      returns(single_tag.merge(two_tags)) do
-        @rds.list_tags_for_resource(@db_instance_id).
-          body['ListTagsForResourceResult']['TagList']
-      end
-      result
-    end
-
-    tests("#remove_tags_from_resource").formats(AWS::RDS::Formats::BASIC) do
-      result = @rds.remove_tags_from_resource(
-                @db_instance_id, single_tag.keys).body
-      returns(two_tags) do
-        @rds.list_tags_for_resource(@db_instance_id).
-          body['ListTagsForResourceResult']['TagList']
-      end
-      result
-    end
-
-    tests("#list_tags_for_resource").
-    formats(AWS::RDS::Formats::LIST_TAGS_FOR_RESOURCE) do
-      result = @rds.list_tags_for_resource(@db_instance_id).body
-      returns(two_tags) do
-        result['ListTagsForResourceResult']['TagList']
-      end
-      result
-    end
-
-  end
-
-  tests('failure') do
-    tests "tagging a nonexisting instance" do
-      raises(Fog::AWS::RDS::NotFound) do
-        @rds.add_tags_to_resource('doesnexist', {'key1' => 'value1'})
-      end
-    end
-    tests "listing tags for a nonexisting instance" do
-      raises(Fog::AWS::RDS::NotFound) do
-        @rds.list_tags_for_resource('doesnexist')
-      end
-    end
-    tests "removing tags for a nonexisting instance" do
-      raises(Fog::AWS::RDS::NotFound) do
-        @rds.remove_tags_from_resource('doesnexist', ['key1'])
-      end
-    end
-  end
-
-  Formatador.display_line "Destroying DB instance #{@db_instance_id}"
-  @db.destroy
-end