fog-aws 3.9.0 → 3.13.0

data/tests/requests/rds/db_snapshot_tests.rb

@@ -1,62 +0,0 @@
-Shindo.tests('Fog::Rds[:aws] | db snapshot requests', ['aws']) do
-
-  @snapshot_format = {
-    'AllocatedStorage'     => Integer,
-    'AvailabilityZone'     => Fog::Nullable::String,
-    'Engine'               => String,
-    'EngineVersion'        => String,
-    'InstanceCreateTime'   => Time,
-    'DBInstanceIdentifier' => String,
-    'DBSnapshotIdentifier' => String,
-    'Iops'                 => Fog::Nullable::Integer,
-    'MasterUsername'       => String,
-    'Port'                 => Fog::Nullable::Integer,
-    'Status'               => String,
-    'StorageType'          => String,
-    'SnapshotType'         => String,
-    'SnapshotCreateTime' => Fog::Nullable::Time,
-  }
-
-  @snapshots_format = {
-    'requestId'   => String
-  }
-
-  @rds_identity = "test_rds"
-
-  Fog::AWS[:rds].create_db_instance(@rds_identity,{
-    "DBInstanceClass"=>"db.m3.xlarge",
-    "Engine"=>"PostgreSQL",
-    "AllocatedStorage"=>100,
-    "MasterUserPassword"=>"password",
-    "MasterUsername"=>"username"
-  })
-
-  @rds = Fog::AWS[:rds].servers.get(@rds_identity)
-
-  tests('success') do
-    @snapshot_id = "testRdsSnapshot"
-    tests("#create_snapshot(#{@rds.identity})").formats(@snapshot_format) do
-      Fog::AWS[:rds].create_db_snapshot(@rds.identity,@snapshot_id).body["CreateDBSnapshotResult"]["DBSnapshot"]
-    end
-
-    Fog.wait_for { Fog::AWS[:rds].snapshots.get(@snapshot_id) }
-    Fog::AWS[:rds].snapshots.get(@snapshot_id).wait_for { ready? }
-
-    tests("#modify_db_snapshot_attribute").formats(@snapshots_format) do
-      Fog::AWS[:rds].modify_db_snapshot_attribute(@snapshot_id, {"Add.MemberId"=>["389480430104"]}).body
-    end
-
-    tests("#copy_db_snapshot (#{@snapshot_id}, target_snapshot_id)").formats(@snapshot_format)  do
-      Fog::AWS[:rds].copy_db_snapshot(@snapshot_id, "target_snapshot_id").body["CopyDBSnapshotResult"]["DBSnapshot"]
-    end
-  end
-
-  tests('failure') do
-    tests("#delete_snapshot('snap-00000000')").raises(Fog::AWS::RDS::NotFound) do
-      Fog::AWS[:rds].delete_db_snapshot(@rds.identity)
-    end
-  end
-
-  @rds.destroy
-
-end

data/tests/requests/rds/describe_events.rb

@@ -1,16 +0,0 @@
-Shindo.tests('AWS::RDS | describe DB events requests',['aws', 'rds']) do
-
-  tests('success') do
-    pending if Fog.mocking?
-
-    tests(
-    '#describe_events'
-    ).formats(AWS::RDS::Formats::EVENT_LIST) do
-      Fog::AWS[:rds].describe_events().body['Events']
-    end
-  end
-
-  tests('failure') do
-    #TODO: What constitutes a failure here?
-  end
-end

data/tests/requests/rds/event_subscription_tests.rb

@@ -1,30 +0,0 @@
-Shindo.tests('AWS::RDS | event subscription requests', ['aws', 'rds']) do
-  pending unless Fog.mocking?
-
-  @name = 'fog'
-  @arn  = 'arn:aws:sns:us-east-1:12345678910:fog'
-
-  tests('success') do
-    tests('#create_event_subscription').formats(AWS::RDS::Formats::CREATE_EVENT_SUBSCRIPTION) do
-      body = Fog::AWS[:rds].create_event_subscription('SubscriptionName' => @name, 'SnsTopicArn' => @arn).body
-
-      returns(@name) { body['CreateEventSubscriptionResult']['EventSubscription']['CustSubscriptionId'] }
-      returns('creating') { body['CreateEventSubscriptionResult']['EventSubscription']['Status'] }
-      body
-    end
-
-    tests("#describe_event_subscriptions").formats(AWS::RDS::Formats::DESCRIBE_EVENT_SUBSCRIPTIONS) do
-      returns('active') { Fog::AWS[:rds].describe_event_subscriptions.body['DescribeEventSubscriptionsResult']['EventSubscriptionsList'].first['Status'] }
-      Fog::AWS[:rds].describe_event_subscriptions.body
-    end
-
-    tests("#delete_event_subscription").formats(AWS::RDS::Formats::BASIC) do
-      body = Fog::AWS[:rds].delete_event_subscription(@name).body
-
-      returns('deleting') { Fog::AWS[:rds].describe_event_subscriptions('SubscriptionName' => @name).body['DescribeEventSubscriptionsResult']['EventSubscriptionsList'].first['Status'] }
-      raises(Fog::AWS::RDS::NotFound) { Fog::AWS[:rds].describe_event_subscriptions('SubscriptionName' => @name) }
-
-      body
-    end
-  end
-end

data/tests/requests/rds/helper.rb

@@ -1,406 +0,0 @@
-class AWS
-  module RDS
-    module Formats
-      BASIC = {
-        'ResponseMetadata' => { 'RequestId' => String }
-      }
-
-      DB_AVAILABILITY_ZONE_OPTION = {
-        'Name' => String
-      }
-
-      DB_PARAMETER_GROUP = {
-        'DBParameterGroupFamily' => String,
-        'DBParameterGroupName' => String,
-        'Description' => String
-      }
-      CREATE_DB_PARAMETER_GROUP = {
-        'ResponseMetadata' => { 'RequestId' => String },
-        'CreateDBParameterGroupResult' => {
-          'DBParameterGroup' => DB_PARAMETER_GROUP
-        }
-      }
-
-      DB_SECURITY_GROUP = {
-        'DBSecurityGroupDescription' => String,
-        'DBSecurityGroupName' => String,
-        'EC2SecurityGroups' => [Fog::Nullable::Hash],
-        'IPRanges' => [Fog::Nullable::Hash],
-        'OwnerId' => Fog::Nullable::String
-      }
-
-      CREATE_DB_SECURITY_GROUP = BASIC.merge({
-        'CreateDBSecurityGroupResult' => {
-          'DBSecurityGroup' => DB_SECURITY_GROUP
-        }
-      })
-
-      AUTHORIZE_DB_SECURITY_GROUP = BASIC.merge({
-        'AuthorizeDBSecurityGroupIngressResult' => {
-          'DBSecurityGroup' => DB_SECURITY_GROUP
-        }
-      })
-
-      REVOKE_DB_SECURITY_GROUP = BASIC.merge({
-        'RevokeDBSecurityGroupIngressResult' => {
-          'DBSecurityGroup' => DB_SECURITY_GROUP
-        }
-      })
-
-      DESCRIBE_DB_SECURITY_GROUP = BASIC.merge({
-        'DescribeDBSecurityGroupsResult' => {
-          'DBSecurityGroups' => [DB_SECURITY_GROUP]
-        }
-      })
-
-      DB_SUBNET_GROUP = {
-        'DBSubnetGroupName' => String,
-        'DBSubnetGroupDescription' => String,
-        'SubnetGroupStatus' => String,
-        'VpcId' => String,
-        'Subnets' => [String]
-      }
-
-      CREATE_DB_SUBNET_GROUP = BASIC.merge({
-        'CreateDBSubnetGroupResult' => {
-          'DBSubnetGroup' => DB_SUBNET_GROUP
-        }
-      })
-
-      DESCRIBE_DB_SUBNET_GROUPS = BASIC.merge({
-        'DescribeDBSubnetGroupsResult' => {
-          'DBSubnetGroups' => [DB_SUBNET_GROUP]
-        }
-      })
-
-      DESCRIBE_DB_PARAMETER_GROUP = {
-        'ResponseMetadata' => { 'RequestId' => String },
-        'DescribeDBParameterGroupsResult' => {
-          'DBParameterGroups' => [DB_PARAMETER_GROUP]
-        }
-      }
-
-      ORDERABLE_DB_INSTANCE_OPTION = {
-        'MultiAZCapable' => Fog::Boolean,
-        'Engine' => String,
-        'LicenseModel' => String,
-        'ReadReplicaCapable' => Fog::Boolean,
-        'EngineVersion' => String,
-        'AvailabilityZones' => [DB_AVAILABILITY_ZONE_OPTION],
-        'DBInstanceClass' => String,
-        'SupportsStorageEncryption' => Fog::Boolean,
-        'SupportsPerformanceInsights' => Fog::Boolean,
-        'StorageType' => String,
-        'SupportsIops' => Fog::Boolean,
-        'SupportsIAMDatabaseAuthentication' => Fog::Boolean,
-        'SupportsEnhancedMonitoring' => Fog::Boolean,
-        'Vpc' => Fog::Boolean
-      }
-
-      DESCRIBE_ORDERABLE_DB_INSTANCE_OPTION = BASIC.merge({
-        'DescribeOrderableDBInstanceOptionsResult' => {
-          'OrderableDBInstanceOptions' => [ORDERABLE_DB_INSTANCE_OPTION]
-        }
-      })
-
-      MODIFY_PARAMETER_GROUP = BASIC.merge({
-        'ModifyDBParameterGroupResult' => {
-          'DBParameterGroupName' => String
-        }
-      })
-
-      DB_PARAMETER = {
-        'ParameterValue' => Fog::Nullable::String,
-        'DataType' => String,
-        'AllowedValues' => Fog::Nullable::String,
-        'Source' => String,
-        'IsModifiable' => Fog::Boolean,
-        'Description' => String,
-        'ParameterName' => String,
-        'ApplyType' => String
-      }
-
-      DESCRIBE_DB_PARAMETERS = BASIC.merge({
-        'DescribeDBParametersResult' => {
-          'Marker' => Fog::Nullable::String,
-          'Parameters' => [DB_PARAMETER]
-        }
-
-      })
-
-      DB_LOG_FILE = {
-        'LastWritten' => Time,
-        'Size' => Integer,
-        'LogFileName' => String
-      }
-
-      DESCRIBE_DB_LOG_FILES = BASIC.merge({
-        'DescribeDBLogFilesResult' => {
-          'Marker' => Fog::Nullable::String,
-          'DBLogFiles' => [DB_LOG_FILE]
-        }
-      })
-
-      SNAPSHOT = {
-        'AllocatedStorage' => Integer,
-        'AvailabilityZone' => Fog::Nullable::String,
-        'DBInstanceIdentifier' => String,
-        'DBSnapshotIdentifier' => String,
-        'EngineVersion' => String,
-        'Engine' => String,
-        'InstanceCreateTime' => Time,
-        'Iops' => Fog::Nullable::Integer,
-        'MasterUsername' => String,
-        'Port' => Fog::Nullable::Integer,
-        'SnapshotCreateTime' => Fog::Nullable::Time,
-        'Status' => String,
-        'SnapshotType' => String,
-        'StorageType' => String,
-      }
-
-      INSTANCE = {
-        'AllocatedStorage'        => Integer,
-        'AutoMinorVersionUpgrade' => Fog::Boolean,
-        'AvailabilityZone'        => Fog::Nullable::String,
-        'BackupRetentionPeriod'   => Integer,
-        'CACertificateIdentifier' => String,
-        'CharacterSetName'        => Fog::Nullable::String,
-        'DBClusterIndentifier'    => Fog::Nullable::String,
-        'DbiResourceId'           => Fog::Nullable::String,
-        'DBInstanceClass'         => String,
-        'DBInstanceIdentifier'    => String,
-        'DBInstanceStatus'        => String,
-        'DBName'                  => Fog::Nullable::String,
-        'DBParameterGroups' => [{
-          'ParameterApplyStatus' => String,
-          'DBParameterGroupName' => String
-        }],
-        'DBSecurityGroups' => [{
-          'Status'              => String,
-          'DBSecurityGroupName' => String
-        }],
-        'DBSubnetGroupName'  => Fog::Nullable::String,
-        'PubliclyAccessible' => Fog::Boolean,
-        'Endpoint' => {
-          'Address' => Fog::Nullable::String,
-          'Port'    => Fog::Nullable::Integer
-        },
-        'Engine'               => String,
-        'EngineVersion'        => String,
-        'InstanceCreateTime'   => Fog::Nullable::Time,
-        'Iops'                 => Fog::Nullable::Integer,
-        'KmsKeyId'             => Fog::Nullable::String,
-        'LatestRestorableTime' => Fog::Nullable::Time,
-        'LicenseModel'         => String,
-        'MasterUsername'       => String,
-        'MultiAZ'              => Fog::Boolean,
-        'PendingModifiedValues' => {
-          'BackupRetentionPeriod' => Fog::Nullable::Integer,
-          'DBInstanceClass'       => Fog::Nullable::String,
-          'EngineVersion'         => Fog::Nullable::String,
-          'MasterUserPassword'    => Fog::Nullable::String,
-          'MultiAZ'               => Fog::Nullable::Boolean,
-          'AllocatedStorage'      => Fog::Nullable::Integer,
-          'Port'                  => Fog::Nullable::Integer
-        },
-        'PreferredBackupWindow'            => String,
-        'PreferredMaintenanceWindow'       => String,
-        'ReadReplicaDBInstanceIdentifiers' => [Fog::Nullable::String],
-        'StorageType'                      => String,
-        'StorageEncrypted'                 => Fog::Boolean,
-        'TdeCredentialArn'                 => Fog::Nullable::String
-      }
-
-      REPLICA_INSTANCE = INSTANCE.merge({
-        'PreferredBackupWindow'                 => Fog::Nullable::String,
-        'ReadReplicaSourceDBInstanceIdentifier' => String
-      })
-
-      CREATE_DB_INSTANCE = BASIC.merge({
-        'CreateDBInstanceResult' => {
-          'DBInstance' => INSTANCE
-        }
-      })
-
-      DESCRIBE_DB_INSTANCES = BASIC.merge({
-        'DescribeDBInstancesResult' =>  {
-          'Marker' => Fog::Nullable::String,
-          'DBInstances' => [INSTANCE]
-        }
-      })
-
-      MODIFY_DB_INSTANCE = BASIC.merge({
-        'ModifyDBInstanceResult' => {
-          'DBInstance' => INSTANCE
-        }
-      })
-
-      DELETE_DB_INSTANCE = BASIC.merge({
-        'DeleteDBInstanceResult' => {
-          'DBInstance' => INSTANCE
-        }
-      })
-
-      REBOOT_DB_INSTANCE = BASIC.merge({
-        'RebootDBInstanceResult' => {
-          'DBInstance' => INSTANCE
-        }
-      })
-
-      CREATE_READ_REPLICA = BASIC.merge({
-        'CreateDBInstanceReadReplicaResult' => {
-          'DBInstance' => REPLICA_INSTANCE
-        }
-      })
-
-      PROMOTE_READ_REPLICA = BASIC.merge({
-        'PromoteReadReplicaResult' => {
-          'DBInstance' => INSTANCE
-        }
-      })
-
-      CREATE_DB_SNAPSHOT = BASIC.merge({
-        'CreateDBSnapshotResult' => {
-          'DBSnapshot' => SNAPSHOT
-        }
-      })
-
-      DESCRIBE_DB_SNAPSHOTS = BASIC.merge({
-        'DescribeDBSnapshotsResult' => {
-          'Marker' => Fog::Nullable::String,
-          'DBSnapshots' => [SNAPSHOT]
-        }
-      })
-      DELETE_DB_SNAPSHOT = BASIC.merge({
-        'DeleteDBSnapshotResult' => {
-          'DBSnapshot' => SNAPSHOT
-        }
-      })
-
-      LIST_TAGS_FOR_RESOURCE = {
-        'ListTagsForResourceResult' => {
-          'TagList' => Fog::Nullable::Hash
-        }
-      }
-
-      EVENT_SUBSCRIPTION = {
-        'CustSubscriptionId' => String,
-        'EventCategories'    => Array,
-        'SourceType'         => Fog::Nullable::String,
-        'Enabled'            => String,
-        'Status'             => String,
-        'CreationTime'       => Time,
-        'SnsTopicArn'        => String
-      }
-
-      CREATE_EVENT_SUBSCRIPTION = {
-        'CreateEventSubscriptionResult' => {
-          'EventSubscription' => EVENT_SUBSCRIPTION
-        }
-      }
-
-      DESCRIBE_EVENT_SUBSCRIPTIONS = {
-        'DescribeEventSubscriptionsResult' => {
-          'EventSubscriptionsList' => [EVENT_SUBSCRIPTION]
-        }
-      }
-
-      DB_ENGINE_VERSION = {
-        'Engine'                     => String,
-        'DBParameterGroupFamily'     => String,
-        'DBEngineDescription'        => String,
-        'EngineVersion'              => String,
-        'DBEngineVersionDescription' => String
-      }
-
-      DB_ENGINE_VERSIONS_LIST = BASIC.merge(
-        'DescribeDBEngineVersionsResult' => {
-          'DBEngineVersions' => [DB_ENGINE_VERSION]
-        }
-      )
-
-      DB_CLUSTER = {
-        'AllocatedStorage'           => String,
-        'BackupRetentionPeriod'      => String,
-        'DBClusterIdentifier'        => String,
-        'DBClusterMembers'           => [{
-          "master"               => Fog::Nullable::Boolean,
-          "DBInstanceIdentifier" => Fog::Nullable::String,
-        }],
-        'DBClusterParameterGroup'    => String,
-        'DBSubnetGroup'              => String,
-        'Endpoint'                   => String,
-        'Engine'                     => String,
-        'EngineVersion'              => String,
-        'MasterUsername'             => String,
-        'Port'                       => String,
-        'PreferredBackupWindow'      => String,
-        'PreferredMaintenanceWindow' => String,
-        'Status'                     => String,
-        'VpcSecurityGroups'          => [{
-          "VpcSecurityGroupId" => Fog::Nullable::String,
-        }]
-      }
-
-      DESCRIBE_DB_CLUSTERS = BASIC.merge({
-        'DescribeDBClustersResult' =>  {
-          'Marker' => Fog::Nullable::String,
-          'DBClusters' => [DB_CLUSTER]
-        }
-      })
-
-      CREATE_DB_CLUSTER = BASIC.merge(
-        'CreateDBClusterResult' => {
-          'DBCluster' => DB_CLUSTER
-        }
-      )
-
-      DELETE_DB_CLUSTER = BASIC.merge(
-        'DeleteDBClusterResult' => {
-          'DBCluster' => DB_CLUSTER
-        }
-      )
-
-      DB_CLUSTER_SNAPSHOT = {
-        'AllocatedStorage'            => Fog::Nullable::Integer,
-        'ClusterCreateTime'           => Fog::Nullable::Time,
-        'DBClusterIdentifier'         => String,
-        'DBClusterSnapshotIdentifier' => String,
-        'Engine'                      => String,
-        'LicenseModel'                => String,
-        'MasterUsername'              => String,
-        'PercentProgress'             => Fog::Nullable::Integer,
-        'Port'                        => Fog::Nullable::Integer,
-        'SnapshotCreateTime'          => Fog::Nullable::Time,
-        'SnapshotType'                => String,
-        'Status'                      => String,
-        'VpcId'                       => Fog::Nullable::String
-      }
-
-      CREATE_DB_CLUSTER_SNAPSHOT = BASIC.merge(
-        'CreateDBClusterSnapshotResult' => {
-          'DBClusterSnapshot' => DB_CLUSTER_SNAPSHOT
-        }
-      )
-
-      DESCRIBE_DB_CLUSTER_SNAPSHOTS = BASIC.merge(
-        'DescribeDBClusterSnapshotsResult' => {
-          'Marker'             => Fog::Nullable::String,
-          'DBClusterSnapshots' => [DB_CLUSTER_SNAPSHOT],
-        }
-      )
-
-      DELETE_DB_CLUSTER_SNAPSHOT = BASIC.merge(
-        'DeleteDBClusterSnapshotResult' => {
-          'DBClusterSnapshot' => DB_CLUSTER_SNAPSHOT,
-        }
-      )
-
-      RESTORE_DB_INSTANCE_FROM_DB_SNAPSHOT = BASIC.merge({
-        'RestoreDBInstanceFromDBSnapshotResult' => {
-          'DBInstance' => INSTANCE
-        }
-      })
-    end
-  end
-end

data/tests/requests/rds/instance_option_tests.rb

@@ -1,27 +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 }
-      returns( true ) { group['StorageType'].length > 2 }
-      returns( false ) { group['SupportsIops'] }
-      returns( true ) { group['SupportsStorageEncryption'] }
-      returns( false ) { group['SupportsPerformanceInsights'] }
-      returns( false ) { group['SupportsIops'] }
-      returns( false ) { group['SupportsIAMDatabaseAuthentication'] }
-      returns( true ) { group['SupportsEnhancedMonitoring'] }
-      body
-    end
-
-  end
-
-end

data/tests/requests/rds/instance_tests.rb

@@ -1,149 +0,0 @@
-Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
-
-  # 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-#{suffix}"
-  @db_final_snapshot_id   = "fog-final-snapshot-#{suffix}"
-  @db_instance_restore_id = "fog-test-#{suffix}"
-
-  tests('success') do
-
-    tests("#create_db_instance").formats(AWS::RDS::Formats::CREATE_DB_INSTANCE) do
-      default_params = rds_default_server_params
-
-      # creation of replicas requires a > 0 BackupRetentionPeriod value
-      # InvalidDBInstanceState => Automated backups are not enabled for this database instance. To enable automated backups, use ModifyDBInstance to set the backup retention period to a non-zero value. (Fog::AWS::RDS::Error)
-      backup_retention_period = 1
-
-      result = Fog::AWS[:rds].create_db_instance(@db_instance_id,
-                                                 'AllocatedStorage'      => default_params.fetch(:allocated_storage),
-                                                 'DBInstanceClass'       => default_params.fetch(:flavor_id),
-                                                 'Engine'                => default_params.fetch(:engine),
-                                                 'EngineVersion'         => default_params.fetch(:version),
-                                                 'MasterUsername'        => default_params.fetch(:master_username),
-                                                 'BackupRetentionPeriod' => backup_retention_period,
-                                                 'MasterUserPassword'    => default_params.fetch(:password)).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
-      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("#restore_db_instance_from_db_snapshot").formats(AWS::RDS::Formats::RESTORE_DB_INSTANCE_FROM_DB_SNAPSHOT) do
-      snapshot = Fog::AWS[:rds].snapshots.get(@db_final_snapshot_id)
-      snapshot.wait_for { state == 'available' }
-      result = Fog::AWS[:rds].restore_db_instance_from_db_snapshot(@db_final_snapshot_id, @db_instance_restore_id).body
-      instance = result['RestoreDBInstanceFromDBSnapshotResult']['DBInstance']
-      returns('creating') { instance['DBInstanceStatus'] }
-      result
-    end
-    restore_server = Fog::AWS[:rds].servers.get(@db_instance_restore_id)
-    restore_server.wait_for { state == 'available' }
-
-    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