fog-aws 3.5.2 → 3.19.0

data/tests/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/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/requests/rds/parameter_request_tests.rb

@@ -1,32 +0,0 @@
-Shindo.tests('AWS::RDS | parameter requests', ['aws', 'rds']) do
-  tests('success') do
-    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/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/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/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)}"
-  Fog::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')
-  Fog::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
-
-  Fog::Formatador.display_line "Destroying DB instance #{@db_instance_id}"
-  @db.destroy
-end

data/tests/requests/redshift/cluster_parameter_group_tests.rb

@@ -1,76 +0,0 @@
-Shindo.tests('Fog::Redshift[:aws] | cluster parameter group requests', ['aws']) do
-  pending if Fog.mocking?
-  suffix = rand(65536).to_s(16)
-  parameter_group = "test-cluster-parameter-group-#{suffix}"
-
-  @cluster_parameter_format = {
-    'Parameter' => {
-      "ParameterValue" => String,
-      "DataType"       => String,
-      "Source"         => String,
-      "IsModifiable"   => Fog::Boolean,
-      "Description"    => String,
-      "ParameterName"  => String
-    }
-  }
-
-  @cluster_parameters_format = {
-    "Parameters"=> [@cluster_parameter_format]
-  }
-
-  @cluster_parameter_group_format = {
-    'ClusterParameterGroup' => {
-      "ParameterGroupFamily" => String,
-      "Description"          => String,
-      "ParameterGroupName"   => String
-    }
-  }
-
-  @cluster_parameter_groups_format = {
-    "ParameterGroups"=> [@cluster_parameter_group_format]
-  }
-
-  @modify_cluster_parameter_group_format = {
-    "ParameterGroupStatus" => String,
-    "ParameterGroupName"   => String
-  }
-
-  tests('success') do
-    tests("create_cluster_parameter_group").formats(@cluster_parameter_group_format) do
-      body = Fog::AWS[:redshift].create_cluster_parameter_group(:parameter_group_name=> parameter_group,
-                                                                :parameter_group_family=>"redshift-1.0",
-                                                                :description=>'testing').body
-      body
-    end
-
-    tests("describe_cluster_parameter_groups").formats(@cluster_parameter_groups_format) do
-      body = Fog::AWS[:redshift].describe_cluster_parameter_groups.body
-      body
-    end
-
-    tests("describe_cluster_parameters").formats(@cluster_parameters_format) do
-      body = Fog::AWS[:redshift].describe_cluster_parameters(:parameter_group_name=>parameter_group).body
-      body
-    end
-
-    tests("modify_cluster_parameter_groups").formats(@modify_cluster_parameter_group_format) do
-      body = Fog::AWS[:redshift].modify_cluster_parameter_group(:parameter_group_name=>parameter_group,
-                                                                :parameters=>{
-                                                                   :parameter_name=>'extra_float_digits',
-                                                                   :parameter_value=>2}).body
-      body
-    end
-
-    tests("delete_cluster_parameter_group") do
-      present = !Fog::AWS[:redshift].describe_cluster_parameter_groups(:parameter_group_name=>parameter_group).body['ParameterGroups'].empty?
-      tests("verify presence before deletion").returns(true) { present }
-
-      Fog::AWS[:redshift].delete_cluster_parameter_group(:parameter_group_name=>parameter_group)
-
-      not_present = Fog::AWS[:redshift].describe_cluster_parameter_groups(:parameter_group_name=>parameter_group).body['ParameterGroups'].empty?
-      tests("verify deletion").returns(true) { not_present }
-     end
-
-  end
-
-end

data/tests/requests/redshift/cluster_security_group_tests.rb

@@ -1,42 +0,0 @@
-Shindo.tests('Fog::Redshift[:aws] | cluster security group requests', ['aws']) do
-  pending if Fog.mocking?
-  suffix     = rand(65536).to_s(16)
-  identifier = "test-cluster-security-group-#{suffix}"
-
-  @cluster_security_group_format = {
-    "ClusterSecurityGroup"  => {
-      "EC2SecurityGroups"        => Fog::Nullable::Array,
-      "IPRanges"                 => Fog::Nullable::Array,
-      "Description"              => String,
-      "ClusterSecurityGroupName" => String
-    }
-  }
-
-  @describe_cluster_security_groups_format = {
-    "ClusterSecurityGroups" => [@cluster_security_group_format]
-  }
-
-  tests('success') do
-    tests("create_cluster_security_group").formats(@cluster_security_group_format) do
-      body = Fog::AWS[:redshift].create_cluster_security_group(:cluster_security_group_name => identifier, :description => 'testing').body
-      body
-    end
-
-    tests("describe_cluster_security_groups").formats(@describe_cluster_security_groups_format) do
-      body = Fog::AWS[:redshift].describe_cluster_security_groups.body
-      body
-    end
-
-    tests("delete_cluster_security_group") do
-      present = !Fog::AWS[:redshift].describe_cluster_security_groups(:cluster_security_group_name => identifier).body['ClusterSecurityGroups'].empty?
-      tests("verify presence before deletion").returns(true) { present }
-
-      Fog::AWS[:redshift].delete_cluster_security_group(:cluster_security_group_name => identifier)
-
-      not_present = Fog::AWS[:redshift].describe_cluster_security_groups(:cluster_security_group_name => identifier).body['ClusterSecurityGroups'].empty?
-      tests("verify deletion").returns(true) { not_present }
-    end
-
-  end
-
-end

data/tests/requests/redshift/cluster_snapshot_tests.rb

@@ -1,73 +0,0 @@
-Shindo.tests('Fog::Redshift[:aws] | cluster snapshot requests', ['aws']) do
-  pending if Fog.mocking?
-  suffix = rand(65536).to_s(16)
-  identifier = "test-snapshot-#{suffix}"
-  cluster    = "test-cluster-#{suffix}"
-  start_time = Fog::Time.now.to_iso8601_basic
-  @cluster_snapshot_format = {
-    'Snapshot' => {
-      "AccountsWithRestoreAccess"              => Fog::Nullable::Array,
-      "Port"                                   => Integer,
-      "SnapshotIdentifier"                     => String,
-      "OwnerAccount"                           => String,
-      "Status"                                 => String,
-      "SnapshotType"                           => String,
-      "ClusterVersion"                         => String,
-      "EstimatedSecondsToCompletion"           => Integer,
-      "SnapshotCreateTime"                     => Time,
-      "Encrypted"                              => Fog::Boolean,
-      "NumberOfNodes"                          => Integer,
-      "DBName"                                 => String,
-      "CurrentBackupRateInMegaBytesPerSecond"  => Float,
-      "ClusterCreateTime"                      => Time,
-      "AvailabilityZone"                       => String,
-      "ActualIncrementalBackupSizeInMegaBytes" => Float,
-      "TotalBackupSizeInMegaBytes"             => Float,
-      "ElapsedTimeInSeconds"                   => Integer,
-      "BackupProgressInMegaBytes"              => Float,
-      "NodeType"                               => String,
-      "ClusterIdentifier"                      => String,
-      "MasterUsername"                         => String
-    }
-  }
-
-  @describe_cluster_snapshots_format = {
-    "Snapshots" => [@cluster_snapshot_format]
-  }
-
-  tests('success') do
-    tests("create_cluster_snapshot").formats(@cluster_snapshot_format) do
-      Fog::AWS[:redshift].create_cluster(:cluster_identifier   => cluster,
-                                         :master_user_password => 'Pass1234',
-                                         :master_username      => 'testuser',
-                                         :node_type            => 'dw.hs1.xlarge',
-                                         :cluster_type         => 'single-node')
-      Fog.wait_for do
-        "available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>cluster).body['ClusterSet'].first['Cluster']['ClusterStatus']
-      end
-      body = Fog::AWS[:redshift].create_cluster_snapshot(:snapshot_identifier => identifier,
-                                                         :cluster_identifier  => cluster).body
-      body
-    end
-
-    tests('describe_cluster_snaphots').formats(@describe_cluster_snapshots_format) do
-      sleep 30 unless Fog.mocking?
-      body = Fog::AWS[:redshift].describe_cluster_snapshots(:start_time=>start_time).body
-      body
-    end
-
-    tests('delete_cluster_snapshot').formats(@cluster_snapshot_format) do
-      Fog.wait_for do
-        "available" == Fog::AWS[:redshift].describe_cluster_snapshots(:snapshot_identifier=>identifier).body['Snapshots'].first['Snapshot']['Status']
-      end
-      sleep 30 unless Fog.mocking?
-      body = Fog::AWS[:redshift].delete_cluster_snapshot(:snapshot_identifier=>identifier).body
-      body
-    end
-
-    Fog::AWS[:redshift].delete_cluster(:cluster_identifier          => cluster,
-                                       :skip_final_cluster_snapshot => true)
-
-  end
-
-end

data/tests/requests/redshift/cluster_tests.rb

@@ -1,80 +0,0 @@
-Shindo.tests('Fog::Redshift[:aws] | cluster requests', ['aws']) do
-  pending if Fog.mocking?
-  identifier = "test-cluster-#{rand(65536).to_s(16)}"
-
-  @cluster_format = {
-    'Cluster' => {
-      "ClusterParameterGroups"  => [{
-        "ClusterParameterGroup" => {
-          "ParameterApplyStatus"  => String,
-          "ParameterGroupName"    => String
-        }
-      }],
-      "ClusterSecurityGroups"  => [{
-        'ClusterSecurityGroup' => {
-          "Status"                   => String,
-          "ClusterSecurityGroupName" => String
-        }
-      }],
-      "VpcSecurityGroups"     => Fog::Nullable::Array,
-      "EndPoint"              => Fog::Nullable::Hash,
-      "PendingModifiedValues" => Fog::Nullable::Hash,
-      "RestoreStatus"         => Fog::Nullable::Hash,
-      "ClusterVersion"        => String,
-      "ClusterStatus"         => String,
-      "Encrypted"             => Fog::Boolean,
-      "NumberOfNodes"         => Integer,
-      "PubliclyAccessible"    => Fog::Boolean,
-      "AutomatedSnapshotRetentionPeriod" => Integer,
-      "DBName"                => String,
-      "PreferredMaintenanceWindow" => String,
-      "NodeType"              => String,
-      "ClusterIdentifier"     => String,
-      "AllowVersionUpgrade"   => Fog::Boolean,
-      "MasterUsername"        => String
-    }
-  }
-  @describe_clusters_format = {
-    "ClusterSet" => [{
-      'Cluster' => @cluster_format['Cluster'].merge({"ClusterCreateTime"=>Time, "AvailabilityZone"=>String, "EndPoint"=>{"Port"=>Integer, "Address"=>String}})
-    }]
-  }
-
-  tests('success') do
-    tests('create_cluster').formats(@cluster_format) do
-      body = Fog::AWS[:redshift].create_cluster(:cluster_identifier   => identifier,
-                                                :master_user_password => 'Password1234',
-                                                :master_username      => 'testuser',
-                                                :node_type            => 'dw.hs1.xlarge',
-                                                :cluster_type         => 'single-node').body
-      Fog.wait_for do
-        "available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body['ClusterSet'].first['Cluster']['ClusterStatus']
-      end
-      body
-    end
-
-    tests('describe_clusters').formats(@describe_clusters_format["ClusterSet"]) do
-      sleep 30 unless Fog.mocking?
-      body = Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body["ClusterSet"]
-      body
-    end
-
-    tests('reboot_cluster') do
-      sleep 30 unless Fog.mocking?
-      body = Fog::AWS[:redshift].reboot_cluster(:cluster_identifier=>identifier).body
-      tests("verify reboot").returns("rebooting") { body['Cluster']['ClusterStatus']}
-      body
-    end
-
-    tests('delete_cluster') do
-      Fog.wait_for do
-        "available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body['ClusterSet'].first['Cluster']['ClusterStatus']
-      end
-      sleep 30 unless Fog.mocking?
-      body = Fog::AWS[:redshift].delete_cluster(:cluster_identifier=>identifier, :skip_final_cluster_snapshot=>true).body
-      tests("verify delete").returns("deleting") { body['Cluster']['ClusterStatus']}
-      body
-    end
-  end
-
-end

data/tests/requests/ses/helper.rb

@@ -1,9 +0,0 @@
-class AWS
-  module SES
-    module Formats
-      BASIC = {
-        'ResponseMetadata' => {'RequestId' => String}
-      }
-    end
-  end
-end

data/tests/requests/ses/verified_domain_identity_tests.rb

@@ -1,16 +0,0 @@
-Shindo.tests('AWS::SES | verified domain identity requests', ['aws', 'ses']) do
-
-  tests('success') do
-
-    tests("#verify_domain_identity('example.com')").formats(AWS::SES::Formats::BASIC) do
-      pending if Fog.mocking?
-      Fog::AWS[:ses].verify_domain_identity('example.com').body
-    end
-
-  end
-
-  tests('failure') do
-
-  end
-
-end