ktheory-fog 1.1.2

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

@@ -0,0 +1,68 @@
+Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests("#create_db_parameter_groups").formats(AWS::RDS::Formats::CREATE_DB_PARAMETER_GROUP) do
+      pending if Fog.mocking?
+      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
+      pending if Fog.mocking?
+
+      body = Fog::AWS[:rds].describe_db_parameter_groups().body
+      
+      returns(3) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}      
+      body
+    end
+
+    tests("#describe_db_parameter_groups('fog-group)").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
+      pending if Fog.mocking?
+
+      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
+      pending if Fog.mocking?
+      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
+    pending if Fog.mocking?
+    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

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

@@ -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'].detect{|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'].detect{|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'].detect{|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'].detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['Status']}
+      returns(@owner_id) { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].detect{|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'].detect{|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/ses/helper.rb

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

data/tests/aws/requests/ses/verified_email_address_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('AWS::SES | verified email address requests', ['aws', 'ses']) do
+
+  tests('success') do
+
+    tests("#verify_email_address('test@example.com')").formats(AWS::SES::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:ses].verify_email_address('test@example.com').body
+    end
+
+    tests("#list_verified_email_addresses").formats(AWS::SES::Formats::BASIC.merge('VerifiedEmailAddresses' => [String])) do
+      pending if Fog.mocking?
+      Fog::AWS[:ses].list_verified_email_addresses.body
+    end
+
+    # email won't be there to delete, but succeeds regardless
+    tests("#delete_verified_email_address('test@example.com')").formats(AWS::SES::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:ses].delete_verified_email_address('notaanemail@example.com').body
+    end
+
+  end
+
+  tests('failure') do
+
+  end
+
+end

data/tests/aws/requests/simpledb/attributes_tests.rb

@@ -0,0 +1,86 @@
+Shindo.tests('AWS::SimpleDB | attributes requests', ['aws']) do
+
+  @domain_name = "fog_domain_#{Time.now.to_f.to_s.gsub('.','')}"
+
+  Fog::AWS[:simpledb].create_domain(@domain_name)
+
+  tests('success') do
+
+    tests("#batch_put_attributes('#{@domain_name}', { 'a' => { 'b' => 'c', 'd' => 'e' }, 'x' => { 'y' => 'z' } }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      Fog::AWS[:simpledb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c', 'd' => 'e' }, 'x' => { 'y' => 'z' } }).body
+    end
+
+    tests("#get_attributes('#{@domain_name}', 'a', {'ConsistentRead' => true}).body['Attributes']").returns({'b' => ['c'], 'd' => ['e']}) do
+      Fog::AWS[:simpledb].get_attributes(@domain_name, 'a', {'ConsistentRead' => true}).body['Attributes']
+    end
+
+    tests("#get_attributes('#{@domain_name}', 'AttributeName' => 'notanattribute')").succeeds do
+      Fog::AWS[:simpledb].get_attributes(@domain_name, 'AttributeName' => 'notanattribute')
+    end
+
+    tests("#select('select * from #{@domain_name}', {'ConsistentRead' => true}).body['Items']").returns({'a' => { 'b' => ['c'], 'd' => ['e']}, 'x' => { 'y' => ['z'] } }) do
+      pending if Fog.mocking?
+      Fog::AWS[:simpledb].select("select * from #{@domain_name}", {'ConsistentRead' => true}).body['Items']
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '1' }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      Fog::AWS[:simpledb].put_attributes(@domain_name, 'conditional', { 'version' => '1' }).body
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      Fog::AWS[:simpledb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body
+    end
+
+    # Verify that we can delete individual attributes.
+    tests("#delete_attributes('#{@domain_name}', 'a', {'d' => []})").succeeds do
+      Fog::AWS[:simpledb].delete_attributes(@domain_name, 'a', {'d' => []}).body
+    end
+
+    # Verify that individually deleted attributes are actually removed.
+    tests("#get_attributes('#{@domain_name}', 'a', {'AttributeName' => ['d'], 'ConsistentRead' => true}).body['Attributes']").returns({}) do
+      Fog::AWS[:simpledb].get_attributes(@domain_name, 'a', {'AttributeName' => ['d'], 'ConsistentRead' => true}).body['Attributes']
+    end
+
+    tests("#delete_attributes('#{@domain_name}', 'a').body").formats(AWS::SimpleDB::Formats::BASIC) do
+      Fog::AWS[:simpledb].delete_attributes(@domain_name, 'a').body
+    end
+
+    # Verify that we can delete entire domain, item combinations.
+    tests("#delete_attributes('#{@domain_name}', 'a').body").succeeds do
+      Fog::AWS[:simpledb].delete_attributes(@domain_name, 'a').body
+    end
+
+    # Verify that deleting a domain, item combination removes all related attributes.
+    tests("#get_attributes('#{@domain_name}', 'a', {'ConsistentRead' => true}).body['Attributes']").returns({}) do
+      Fog::AWS[:simpledb].get_attributes(@domain_name, 'a', {'ConsistentRead' => true}).body['Attributes']
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })").raises(Excon::Errors::BadRequest) do
+      Fog::AWS[:simpledb].batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
+    end
+
+    tests("#get_attributes('notadomain', 'a')").raises(Excon::Errors::BadRequest) do
+      Fog::AWS[:simpledb].get_attributes('notadomain', 'a')
+    end
+
+    tests("#put_attributes('notadomain', 'conditional', { 'version' => '1' })").raises(Excon::Errors::BadRequest) do
+      Fog::AWS[:simpledb].put_attributes('notadomain', 'foo', { 'version' => '1' })
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])").raises(Excon::Errors::Conflict) do
+      Fog::AWS[:simpledb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])
+    end
+
+    tests("#delete_attributes('notadomain', 'a')").raises(Excon::Errors::BadRequest) do
+      Fog::AWS[:simpledb].delete_attributes('notadomain', 'a')
+    end
+
+  end
+
+  Fog::AWS[:simpledb].delete_domain(@domain_name)
+
+end

data/tests/aws/requests/simpledb/domain_tests.rb

@@ -0,0 +1,51 @@
+Shindo.tests('AWS::SimpleDB | domain requests', ['aws']) do
+
+  @domain_metadata_format = AWS::SimpleDB::Formats::BASIC.merge({
+    'AttributeNameCount'        => Integer,
+    'AttributeNamesSizeBytes'   => Integer,
+    'AttributeValueCount'       => Integer,
+    'AttributeValuesSizeBytes'  => Integer,
+    'ItemCount'                 => Integer,
+    'ItemNamesSizeBytes'        => Integer,
+    'Timestamp'                 => Time
+  })
+
+  @domain_name = "fog_domain_#{Time.now.to_f.to_s.gsub('.','')}"
+
+  tests('success') do
+
+    tests("#create_domain(#{@domain_name})").formats(AWS::SimpleDB::Formats::BASIC) do
+      Fog::AWS[:simpledb].create_domain(@domain_name).body
+    end
+
+    tests("#create_domain(#{@domain_name})").succeeds do
+      Fog::AWS[:simpledb].create_domain(@domain_name)
+    end
+
+    tests("#domain_metadata(#{@domain_name})").formats(@domain_metadata_format) do
+      Fog::AWS[:simpledb].domain_metadata(@domain_name).body
+    end
+
+    tests("#list_domains").formats(AWS::SimpleDB::Formats::BASIC.merge('Domains' => [String])) do
+      Fog::AWS[:simpledb].list_domains.body
+    end
+
+    tests("#delete_domain(#{@domain_name})").formats(AWS::SimpleDB::Formats::BASIC) do
+      Fog::AWS[:simpledb].delete_domain(@domain_name).body
+    end
+
+    tests("#delete_domain(#{@domain_name})").succeeds do
+      Fog::AWS[:simpledb].delete_domain(@domain_name)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#domain_metadata('notadomain')").raises(Excon::Errors::BadRequest) do
+      Fog::AWS[:simpledb].domain_metadata('notadomain')
+    end
+
+  end
+
+end

data/tests/aws/requests/simpledb/helper.rb

@@ -0,0 +1,16 @@
+class AWS
+
+  module SimpleDB
+
+    module Formats
+
+      BASIC = {
+        'BoxUsage'  => Float,
+        'RequestId' => String
+      }
+
+    end
+
+  end
+
+end

data/tests/aws/requests/sns/helper.rb

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

data/tests/aws/requests/sns/subscription_tests.rb

@@ -0,0 +1,86 @@
+Shindo.tests('AWS::SES | topic lifecycle tests', ['aws', 'sns']) do
+
+  unless Fog.mocking?
+    @topic_arn = Fog::AWS[:sns].create_topic('fog_subscription_tests').body['TopicArn']
+    @queue_url = Fog::AWS[:sqs].create_queue('fog_subscription_tests').body['QueueUrl']
+    @queue_arn = Fog::AWS[:sqs].get_queue_attributes(@queue_url, 'QueueArn').body['Attributes']['QueueArn']
+    Fog::AWS[:sqs].set_queue_attributes(
+      @queue_url,
+      'Policy',
+      MultiJson.encode({
+        'Id' => @topic_arn,
+        'Statement' => {
+          'Action'    => 'sqs:SendMessage',
+          'Condition' => {
+            'StringEquals' => { 'aws:SourceArn' => @topic_arn }
+          },
+          'Effect'    => 'Allow',
+          'Principal' => { 'AWS' => '*' },
+          'Resource'  => @queue_arn,
+          'Sid'       => "#{@topic_arn}+sqs:SendMessage"
+        },
+        'Version' => '2008-10-17'
+      })
+    )
+  end
+
+  tests('success') do
+
+    tests("#subscribe('#{@topic_arn}', '#{@queue_arn}', 'sqs')").formats(AWS::SNS::Formats::BASIC.merge('SubscriptionArn' => String)) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:sns].subscribe(@topic_arn, @queue_arn, 'sqs').body
+      @subscription_arn = body['SubscriptionArn']
+      body
+    end
+
+    list_subscriptions_format = AWS::SNS::Formats::BASIC.merge({
+      'Subscriptions' => [{
+        'Endpoint'        => String,
+        'Owner'           => String,
+        'Protocol'        => String,
+        'SubscriptionArn' => String,
+        'TopicArn'        => String
+      }]
+    })
+
+    tests("#list_subscriptions").formats(list_subscriptions_format) do
+      pending if Fog.mocking?
+      Fog::AWS[:sns].list_subscriptions.body
+    end
+
+    tests("#list_subscriptions_by_topic('#{@topic_arn}')").formats(list_subscriptions_format) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:sns].list_subscriptions_by_topic(@topic_arn).body
+    end
+
+    tests("#publish('#{@topic_arn}', 'message')").formats(AWS::SNS::Formats::BASIC.merge('MessageId' => String)) do
+      pending if Fog.mocking?
+      body = Fog::AWS[:sns].publish(@topic_arn, 'message').body
+    end
+
+    tests("#receive_message('#{@queue_url}')...").returns('message') do
+      pending if Fog.mocking?
+      message = nil
+      Fog.wait_for do
+        message = Fog::AWS[:sqs].receive_message(@queue_url).body['Message'].first
+      end
+      MultiJson.decode(message['Body'])['Message']
+    end
+
+    tests("#unsubscribe('#{@subscription_arn}')").formats(AWS::SNS::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:sns].unsubscribe(@subscription_arn).body
+    end
+
+  end
+
+  tests('failure') do
+
+  end
+
+  unless Fog.mocking?
+    Fog::AWS[:sns].delete_topic(@topic_arn)
+    Fog::AWS[:sqs].delete_queue(@queue_url)
+  end
+
+end