fog-aws 0.0.5

data/tests/requests/rds/instance_option_tests.rb

@@ -0,0 +1,21 @@
+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/requests/rds/instance_tests.rb

@@ -0,0 +1,133 @@
+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/requests/rds/log_file_tests.rb

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,34 @@
+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/requests/rds/security_group_tests.rb

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,78 @@
+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